﻿#if USE_UNI_LUA
using LuaAPI = UniLua.Lua;
using RealStatePtr = UniLua.ILuaState;
using LuaCSFunction = UniLua.CSharpFunctionDelegate;
#else
using LuaAPI = XLua.LuaDLL.Lua;
using RealStatePtr = System.IntPtr;
using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
#endif

using XLua;
using System.Collections.Generic;


namespace XLua.CSObjectWrap
{
    using Utils = XLua.Utils;
    
    public class UnityEngineAIObstacleAvoidanceTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.AI.ObstacleAvoidanceType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.AI.ObstacleAvoidanceType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.AI.ObstacleAvoidanceType), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NoObstacleAvoidance", UnityEngine.AI.ObstacleAvoidanceType.NoObstacleAvoidance);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LowQualityObstacleAvoidance", UnityEngine.AI.ObstacleAvoidanceType.LowQualityObstacleAvoidance);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MedQualityObstacleAvoidance", UnityEngine.AI.ObstacleAvoidanceType.MedQualityObstacleAvoidance);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GoodQualityObstacleAvoidance", UnityEngine.AI.ObstacleAvoidanceType.GoodQualityObstacleAvoidance);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HighQualityObstacleAvoidance", UnityEngine.AI.ObstacleAvoidanceType.HighQualityObstacleAvoidance);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.AI.ObstacleAvoidanceType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAIObstacleAvoidanceType(L, (UnityEngine.AI.ObstacleAvoidanceType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "NoObstacleAvoidance"))
                {
                    translator.PushUnityEngineAIObstacleAvoidanceType(L, UnityEngine.AI.ObstacleAvoidanceType.NoObstacleAvoidance);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LowQualityObstacleAvoidance"))
                {
                    translator.PushUnityEngineAIObstacleAvoidanceType(L, UnityEngine.AI.ObstacleAvoidanceType.LowQualityObstacleAvoidance);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MedQualityObstacleAvoidance"))
                {
                    translator.PushUnityEngineAIObstacleAvoidanceType(L, UnityEngine.AI.ObstacleAvoidanceType.MedQualityObstacleAvoidance);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "GoodQualityObstacleAvoidance"))
                {
                    translator.PushUnityEngineAIObstacleAvoidanceType(L, UnityEngine.AI.ObstacleAvoidanceType.GoodQualityObstacleAvoidance);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "HighQualityObstacleAvoidance"))
                {
                    translator.PushUnityEngineAIObstacleAvoidanceType(L, UnityEngine.AI.ObstacleAvoidanceType.HighQualityObstacleAvoidance);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.AI.ObstacleAvoidanceType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AI.ObstacleAvoidanceType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEnginePlayModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.PlayMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.PlayMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.PlayMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StopSameLayer", UnityEngine.PlayMode.StopSameLayer);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StopAll", UnityEngine.PlayMode.StopAll);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.PlayMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEnginePlayMode(L, (UnityEngine.PlayMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "StopSameLayer"))
                {
                    translator.PushUnityEnginePlayMode(L, UnityEngine.PlayMode.StopSameLayer);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "StopAll"))
                {
                    translator.PushUnityEnginePlayMode(L, UnityEngine.PlayMode.StopAll);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.PlayMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.PlayMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineQueueModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.QueueMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.QueueMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.QueueMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CompleteOthers", UnityEngine.QueueMode.CompleteOthers);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlayNow", UnityEngine.QueueMode.PlayNow);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.QueueMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineQueueMode(L, (UnityEngine.QueueMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "CompleteOthers"))
                {
                    translator.PushUnityEngineQueueMode(L, UnityEngine.QueueMode.CompleteOthers);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PlayNow"))
                {
                    translator.PushUnityEngineQueueMode(L, UnityEngine.QueueMode.PlayNow);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.QueueMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.QueueMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAnimationBlendModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.AnimationBlendMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.AnimationBlendMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.AnimationBlendMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Blend", UnityEngine.AnimationBlendMode.Blend);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Additive", UnityEngine.AnimationBlendMode.Additive);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.AnimationBlendMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAnimationBlendMode(L, (UnityEngine.AnimationBlendMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Blend"))
                {
                    translator.PushUnityEngineAnimationBlendMode(L, UnityEngine.AnimationBlendMode.Blend);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Additive"))
                {
                    translator.PushUnityEngineAnimationBlendMode(L, UnityEngine.AnimationBlendMode.Additive);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.AnimationBlendMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AnimationBlendMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAnimationPlayModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.AnimationPlayMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.AnimationPlayMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.AnimationPlayMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Stop", UnityEngine.AnimationPlayMode.Stop);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Queue", UnityEngine.AnimationPlayMode.Queue);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mix", UnityEngine.AnimationPlayMode.Mix);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.AnimationPlayMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAnimationPlayMode(L, (UnityEngine.AnimationPlayMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Stop"))
                {
                    translator.PushUnityEngineAnimationPlayMode(L, UnityEngine.AnimationPlayMode.Stop);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Queue"))
                {
                    translator.PushUnityEngineAnimationPlayMode(L, UnityEngine.AnimationPlayMode.Queue);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Mix"))
                {
                    translator.PushUnityEngineAnimationPlayMode(L, UnityEngine.AnimationPlayMode.Mix);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.AnimationPlayMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AnimationPlayMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAnimationCullingTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.AnimationCullingType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.AnimationCullingType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.AnimationCullingType), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AlwaysAnimate", UnityEngine.AnimationCullingType.AlwaysAnimate);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BasedOnRenderers", UnityEngine.AnimationCullingType.BasedOnRenderers);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.AnimationCullingType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAnimationCullingType(L, (UnityEngine.AnimationCullingType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "AlwaysAnimate"))
                {
                    translator.PushUnityEngineAnimationCullingType(L, UnityEngine.AnimationCullingType.AlwaysAnimate);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BasedOnRenderers"))
                {
                    translator.PushUnityEngineAnimationCullingType(L, UnityEngine.AnimationCullingType.BasedOnRenderers);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.AnimationCullingType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AnimationCullingType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAvatarTargetWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.AvatarTarget), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.AvatarTarget), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.AvatarTarget), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Root", UnityEngine.AvatarTarget.Root);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Body", UnityEngine.AvatarTarget.Body);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeftFoot", UnityEngine.AvatarTarget.LeftFoot);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RightFoot", UnityEngine.AvatarTarget.RightFoot);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeftHand", UnityEngine.AvatarTarget.LeftHand);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RightHand", UnityEngine.AvatarTarget.RightHand);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.AvatarTarget), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAvatarTarget(L, (UnityEngine.AvatarTarget)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Root"))
                {
                    translator.PushUnityEngineAvatarTarget(L, UnityEngine.AvatarTarget.Root);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Body"))
                {
                    translator.PushUnityEngineAvatarTarget(L, UnityEngine.AvatarTarget.Body);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LeftFoot"))
                {
                    translator.PushUnityEngineAvatarTarget(L, UnityEngine.AvatarTarget.LeftFoot);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RightFoot"))
                {
                    translator.PushUnityEngineAvatarTarget(L, UnityEngine.AvatarTarget.RightFoot);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LeftHand"))
                {
                    translator.PushUnityEngineAvatarTarget(L, UnityEngine.AvatarTarget.LeftHand);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RightHand"))
                {
                    translator.PushUnityEngineAvatarTarget(L, UnityEngine.AvatarTarget.RightHand);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.AvatarTarget!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AvatarTarget! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAvatarIKGoalWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.AvatarIKGoal), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.AvatarIKGoal), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.AvatarIKGoal), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeftFoot", UnityEngine.AvatarIKGoal.LeftFoot);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RightFoot", UnityEngine.AvatarIKGoal.RightFoot);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeftHand", UnityEngine.AvatarIKGoal.LeftHand);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RightHand", UnityEngine.AvatarIKGoal.RightHand);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.AvatarIKGoal), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAvatarIKGoal(L, (UnityEngine.AvatarIKGoal)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "LeftFoot"))
                {
                    translator.PushUnityEngineAvatarIKGoal(L, UnityEngine.AvatarIKGoal.LeftFoot);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RightFoot"))
                {
                    translator.PushUnityEngineAvatarIKGoal(L, UnityEngine.AvatarIKGoal.RightFoot);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LeftHand"))
                {
                    translator.PushUnityEngineAvatarIKGoal(L, UnityEngine.AvatarIKGoal.LeftHand);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RightHand"))
                {
                    translator.PushUnityEngineAvatarIKGoal(L, UnityEngine.AvatarIKGoal.RightHand);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.AvatarIKGoal!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AvatarIKGoal! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAvatarIKHintWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.AvatarIKHint), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.AvatarIKHint), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.AvatarIKHint), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeftKnee", UnityEngine.AvatarIKHint.LeftKnee);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RightKnee", UnityEngine.AvatarIKHint.RightKnee);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeftElbow", UnityEngine.AvatarIKHint.LeftElbow);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RightElbow", UnityEngine.AvatarIKHint.RightElbow);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.AvatarIKHint), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAvatarIKHint(L, (UnityEngine.AvatarIKHint)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "LeftKnee"))
                {
                    translator.PushUnityEngineAvatarIKHint(L, UnityEngine.AvatarIKHint.LeftKnee);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RightKnee"))
                {
                    translator.PushUnityEngineAvatarIKHint(L, UnityEngine.AvatarIKHint.RightKnee);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LeftElbow"))
                {
                    translator.PushUnityEngineAvatarIKHint(L, UnityEngine.AvatarIKHint.LeftElbow);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RightElbow"))
                {
                    translator.PushUnityEngineAvatarIKHint(L, UnityEngine.AvatarIKHint.RightElbow);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.AvatarIKHint!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AvatarIKHint! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAnimatorControllerParameterTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.AnimatorControllerParameterType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.AnimatorControllerParameterType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.AnimatorControllerParameterType), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Float", UnityEngine.AnimatorControllerParameterType.Float);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Int", UnityEngine.AnimatorControllerParameterType.Int);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Bool", UnityEngine.AnimatorControllerParameterType.Bool);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Trigger", UnityEngine.AnimatorControllerParameterType.Trigger);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.AnimatorControllerParameterType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAnimatorControllerParameterType(L, (UnityEngine.AnimatorControllerParameterType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Float"))
                {
                    translator.PushUnityEngineAnimatorControllerParameterType(L, UnityEngine.AnimatorControllerParameterType.Float);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Int"))
                {
                    translator.PushUnityEngineAnimatorControllerParameterType(L, UnityEngine.AnimatorControllerParameterType.Int);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Bool"))
                {
                    translator.PushUnityEngineAnimatorControllerParameterType(L, UnityEngine.AnimatorControllerParameterType.Bool);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Trigger"))
                {
                    translator.PushUnityEngineAnimatorControllerParameterType(L, UnityEngine.AnimatorControllerParameterType.Trigger);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.AnimatorControllerParameterType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AnimatorControllerParameterType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAnimatorRecorderModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.AnimatorRecorderMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.AnimatorRecorderMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.AnimatorRecorderMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Offline", UnityEngine.AnimatorRecorderMode.Offline);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Playback", UnityEngine.AnimatorRecorderMode.Playback);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Record", UnityEngine.AnimatorRecorderMode.Record);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.AnimatorRecorderMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAnimatorRecorderMode(L, (UnityEngine.AnimatorRecorderMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Offline"))
                {
                    translator.PushUnityEngineAnimatorRecorderMode(L, UnityEngine.AnimatorRecorderMode.Offline);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Playback"))
                {
                    translator.PushUnityEngineAnimatorRecorderMode(L, UnityEngine.AnimatorRecorderMode.Playback);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Record"))
                {
                    translator.PushUnityEngineAnimatorRecorderMode(L, UnityEngine.AnimatorRecorderMode.Record);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.AnimatorRecorderMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AnimatorRecorderMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineDurationUnitWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.DurationUnit), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.DurationUnit), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.DurationUnit), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fixed", UnityEngine.DurationUnit.Fixed);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normalized", UnityEngine.DurationUnit.Normalized);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.DurationUnit), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineDurationUnit(L, (UnityEngine.DurationUnit)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Fixed"))
                {
                    translator.PushUnityEngineDurationUnit(L, UnityEngine.DurationUnit.Fixed);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Normalized"))
                {
                    translator.PushUnityEngineDurationUnit(L, UnityEngine.DurationUnit.Normalized);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.DurationUnit!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.DurationUnit! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAnimatorCullingModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.AnimatorCullingMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.AnimatorCullingMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.AnimatorCullingMode), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AlwaysAnimate", UnityEngine.AnimatorCullingMode.AlwaysAnimate);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CullUpdateTransforms", UnityEngine.AnimatorCullingMode.CullUpdateTransforms);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CullCompletely", UnityEngine.AnimatorCullingMode.CullCompletely);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.AnimatorCullingMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAnimatorCullingMode(L, (UnityEngine.AnimatorCullingMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "AlwaysAnimate"))
                {
                    translator.PushUnityEngineAnimatorCullingMode(L, UnityEngine.AnimatorCullingMode.AlwaysAnimate);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CullUpdateTransforms"))
                {
                    translator.PushUnityEngineAnimatorCullingMode(L, UnityEngine.AnimatorCullingMode.CullUpdateTransforms);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CullCompletely"))
                {
                    translator.PushUnityEngineAnimatorCullingMode(L, UnityEngine.AnimatorCullingMode.CullCompletely);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.AnimatorCullingMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AnimatorCullingMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAnimatorUpdateModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.AnimatorUpdateMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.AnimatorUpdateMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.AnimatorUpdateMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", UnityEngine.AnimatorUpdateMode.Normal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AnimatePhysics", UnityEngine.AnimatorUpdateMode.AnimatePhysics);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnscaledTime", UnityEngine.AnimatorUpdateMode.UnscaledTime);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.AnimatorUpdateMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAnimatorUpdateMode(L, (UnityEngine.AnimatorUpdateMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
                {
                    translator.PushUnityEngineAnimatorUpdateMode(L, UnityEngine.AnimatorUpdateMode.Normal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AnimatePhysics"))
                {
                    translator.PushUnityEngineAnimatorUpdateMode(L, UnityEngine.AnimatorUpdateMode.AnimatePhysics);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UnscaledTime"))
                {
                    translator.PushUnityEngineAnimatorUpdateMode(L, UnityEngine.AnimatorUpdateMode.UnscaledTime);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.AnimatorUpdateMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AnimatorUpdateMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineBodyDofWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.BodyDof), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.BodyDof), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.BodyDof), L, null, 11, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SpineFrontBack", UnityEngine.BodyDof.SpineFrontBack);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SpineLeftRight", UnityEngine.BodyDof.SpineLeftRight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SpineRollLeftRight", UnityEngine.BodyDof.SpineRollLeftRight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ChestFrontBack", UnityEngine.BodyDof.ChestFrontBack);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ChestLeftRight", UnityEngine.BodyDof.ChestLeftRight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ChestRollLeftRight", UnityEngine.BodyDof.ChestRollLeftRight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UpperChestFrontBack", UnityEngine.BodyDof.UpperChestFrontBack);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UpperChestLeftRight", UnityEngine.BodyDof.UpperChestLeftRight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UpperChestRollLeftRight", UnityEngine.BodyDof.UpperChestRollLeftRight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LastBodyDof", UnityEngine.BodyDof.LastBodyDof);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.BodyDof), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineBodyDof(L, (UnityEngine.BodyDof)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "SpineFrontBack"))
                {
                    translator.PushUnityEngineBodyDof(L, UnityEngine.BodyDof.SpineFrontBack);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SpineLeftRight"))
                {
                    translator.PushUnityEngineBodyDof(L, UnityEngine.BodyDof.SpineLeftRight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SpineRollLeftRight"))
                {
                    translator.PushUnityEngineBodyDof(L, UnityEngine.BodyDof.SpineRollLeftRight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ChestFrontBack"))
                {
                    translator.PushUnityEngineBodyDof(L, UnityEngine.BodyDof.ChestFrontBack);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ChestLeftRight"))
                {
                    translator.PushUnityEngineBodyDof(L, UnityEngine.BodyDof.ChestLeftRight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ChestRollLeftRight"))
                {
                    translator.PushUnityEngineBodyDof(L, UnityEngine.BodyDof.ChestRollLeftRight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UpperChestFrontBack"))
                {
                    translator.PushUnityEngineBodyDof(L, UnityEngine.BodyDof.UpperChestFrontBack);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UpperChestLeftRight"))
                {
                    translator.PushUnityEngineBodyDof(L, UnityEngine.BodyDof.UpperChestLeftRight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UpperChestRollLeftRight"))
                {
                    translator.PushUnityEngineBodyDof(L, UnityEngine.BodyDof.UpperChestRollLeftRight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LastBodyDof"))
                {
                    translator.PushUnityEngineBodyDof(L, UnityEngine.BodyDof.LastBodyDof);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.BodyDof!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.BodyDof! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineHeadDofWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.HeadDof), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.HeadDof), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.HeadDof), L, null, 14, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NeckFrontBack", UnityEngine.HeadDof.NeckFrontBack);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NeckLeftRight", UnityEngine.HeadDof.NeckLeftRight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NeckRollLeftRight", UnityEngine.HeadDof.NeckRollLeftRight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HeadFrontBack", UnityEngine.HeadDof.HeadFrontBack);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HeadLeftRight", UnityEngine.HeadDof.HeadLeftRight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HeadRollLeftRight", UnityEngine.HeadDof.HeadRollLeftRight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeftEyeDownUp", UnityEngine.HeadDof.LeftEyeDownUp);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeftEyeInOut", UnityEngine.HeadDof.LeftEyeInOut);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RightEyeDownUp", UnityEngine.HeadDof.RightEyeDownUp);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RightEyeInOut", UnityEngine.HeadDof.RightEyeInOut);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JawDownUp", UnityEngine.HeadDof.JawDownUp);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JawLeftRight", UnityEngine.HeadDof.JawLeftRight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LastHeadDof", UnityEngine.HeadDof.LastHeadDof);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.HeadDof), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineHeadDof(L, (UnityEngine.HeadDof)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "NeckFrontBack"))
                {
                    translator.PushUnityEngineHeadDof(L, UnityEngine.HeadDof.NeckFrontBack);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NeckLeftRight"))
                {
                    translator.PushUnityEngineHeadDof(L, UnityEngine.HeadDof.NeckLeftRight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NeckRollLeftRight"))
                {
                    translator.PushUnityEngineHeadDof(L, UnityEngine.HeadDof.NeckRollLeftRight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "HeadFrontBack"))
                {
                    translator.PushUnityEngineHeadDof(L, UnityEngine.HeadDof.HeadFrontBack);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "HeadLeftRight"))
                {
                    translator.PushUnityEngineHeadDof(L, UnityEngine.HeadDof.HeadLeftRight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "HeadRollLeftRight"))
                {
                    translator.PushUnityEngineHeadDof(L, UnityEngine.HeadDof.HeadRollLeftRight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LeftEyeDownUp"))
                {
                    translator.PushUnityEngineHeadDof(L, UnityEngine.HeadDof.LeftEyeDownUp);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LeftEyeInOut"))
                {
                    translator.PushUnityEngineHeadDof(L, UnityEngine.HeadDof.LeftEyeInOut);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RightEyeDownUp"))
                {
                    translator.PushUnityEngineHeadDof(L, UnityEngine.HeadDof.RightEyeDownUp);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RightEyeInOut"))
                {
                    translator.PushUnityEngineHeadDof(L, UnityEngine.HeadDof.RightEyeInOut);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "JawDownUp"))
                {
                    translator.PushUnityEngineHeadDof(L, UnityEngine.HeadDof.JawDownUp);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "JawLeftRight"))
                {
                    translator.PushUnityEngineHeadDof(L, UnityEngine.HeadDof.JawLeftRight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LastHeadDof"))
                {
                    translator.PushUnityEngineHeadDof(L, UnityEngine.HeadDof.LastHeadDof);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.HeadDof!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.HeadDof! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineLegDofWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.LegDof), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.LegDof), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.LegDof), L, null, 10, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UpperLegFrontBack", UnityEngine.LegDof.UpperLegFrontBack);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UpperLegInOut", UnityEngine.LegDof.UpperLegInOut);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UpperLegRollInOut", UnityEngine.LegDof.UpperLegRollInOut);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LegCloseOpen", UnityEngine.LegDof.LegCloseOpen);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LegRollInOut", UnityEngine.LegDof.LegRollInOut);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FootCloseOpen", UnityEngine.LegDof.FootCloseOpen);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FootInOut", UnityEngine.LegDof.FootInOut);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ToesUpDown", UnityEngine.LegDof.ToesUpDown);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LastLegDof", UnityEngine.LegDof.LastLegDof);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.LegDof), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineLegDof(L, (UnityEngine.LegDof)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "UpperLegFrontBack"))
                {
                    translator.PushUnityEngineLegDof(L, UnityEngine.LegDof.UpperLegFrontBack);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UpperLegInOut"))
                {
                    translator.PushUnityEngineLegDof(L, UnityEngine.LegDof.UpperLegInOut);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UpperLegRollInOut"))
                {
                    translator.PushUnityEngineLegDof(L, UnityEngine.LegDof.UpperLegRollInOut);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LegCloseOpen"))
                {
                    translator.PushUnityEngineLegDof(L, UnityEngine.LegDof.LegCloseOpen);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LegRollInOut"))
                {
                    translator.PushUnityEngineLegDof(L, UnityEngine.LegDof.LegRollInOut);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FootCloseOpen"))
                {
                    translator.PushUnityEngineLegDof(L, UnityEngine.LegDof.FootCloseOpen);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FootInOut"))
                {
                    translator.PushUnityEngineLegDof(L, UnityEngine.LegDof.FootInOut);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ToesUpDown"))
                {
                    translator.PushUnityEngineLegDof(L, UnityEngine.LegDof.ToesUpDown);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LastLegDof"))
                {
                    translator.PushUnityEngineLegDof(L, UnityEngine.LegDof.LastLegDof);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.LegDof!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.LegDof! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineArmDofWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ArmDof), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ArmDof), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ArmDof), L, null, 11, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ShoulderDownUp", UnityEngine.ArmDof.ShoulderDownUp);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ShoulderFrontBack", UnityEngine.ArmDof.ShoulderFrontBack);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ArmDownUp", UnityEngine.ArmDof.ArmDownUp);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ArmFrontBack", UnityEngine.ArmDof.ArmFrontBack);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ArmRollInOut", UnityEngine.ArmDof.ArmRollInOut);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ForeArmCloseOpen", UnityEngine.ArmDof.ForeArmCloseOpen);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ForeArmRollInOut", UnityEngine.ArmDof.ForeArmRollInOut);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HandDownUp", UnityEngine.ArmDof.HandDownUp);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HandInOut", UnityEngine.ArmDof.HandInOut);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LastArmDof", UnityEngine.ArmDof.LastArmDof);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ArmDof), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineArmDof(L, (UnityEngine.ArmDof)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "ShoulderDownUp"))
                {
                    translator.PushUnityEngineArmDof(L, UnityEngine.ArmDof.ShoulderDownUp);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ShoulderFrontBack"))
                {
                    translator.PushUnityEngineArmDof(L, UnityEngine.ArmDof.ShoulderFrontBack);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ArmDownUp"))
                {
                    translator.PushUnityEngineArmDof(L, UnityEngine.ArmDof.ArmDownUp);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ArmFrontBack"))
                {
                    translator.PushUnityEngineArmDof(L, UnityEngine.ArmDof.ArmFrontBack);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ArmRollInOut"))
                {
                    translator.PushUnityEngineArmDof(L, UnityEngine.ArmDof.ArmRollInOut);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ForeArmCloseOpen"))
                {
                    translator.PushUnityEngineArmDof(L, UnityEngine.ArmDof.ForeArmCloseOpen);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ForeArmRollInOut"))
                {
                    translator.PushUnityEngineArmDof(L, UnityEngine.ArmDof.ForeArmRollInOut);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "HandDownUp"))
                {
                    translator.PushUnityEngineArmDof(L, UnityEngine.ArmDof.HandDownUp);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "HandInOut"))
                {
                    translator.PushUnityEngineArmDof(L, UnityEngine.ArmDof.HandInOut);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LastArmDof"))
                {
                    translator.PushUnityEngineArmDof(L, UnityEngine.ArmDof.LastArmDof);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ArmDof!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ArmDof! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineFingerDofWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.FingerDof), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.FingerDof), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.FingerDof), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ProximalDownUp", UnityEngine.FingerDof.ProximalDownUp);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ProximalInOut", UnityEngine.FingerDof.ProximalInOut);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IntermediateCloseOpen", UnityEngine.FingerDof.IntermediateCloseOpen);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DistalCloseOpen", UnityEngine.FingerDof.DistalCloseOpen);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LastFingerDof", UnityEngine.FingerDof.LastFingerDof);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.FingerDof), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineFingerDof(L, (UnityEngine.FingerDof)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "ProximalDownUp"))
                {
                    translator.PushUnityEngineFingerDof(L, UnityEngine.FingerDof.ProximalDownUp);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ProximalInOut"))
                {
                    translator.PushUnityEngineFingerDof(L, UnityEngine.FingerDof.ProximalInOut);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "IntermediateCloseOpen"))
                {
                    translator.PushUnityEngineFingerDof(L, UnityEngine.FingerDof.IntermediateCloseOpen);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DistalCloseOpen"))
                {
                    translator.PushUnityEngineFingerDof(L, UnityEngine.FingerDof.DistalCloseOpen);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LastFingerDof"))
                {
                    translator.PushUnityEngineFingerDof(L, UnityEngine.FingerDof.LastFingerDof);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.FingerDof!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.FingerDof! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineHumanPartDofWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.HumanPartDof), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.HumanPartDof), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.HumanPartDof), L, null, 18, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Body", UnityEngine.HumanPartDof.Body);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Head", UnityEngine.HumanPartDof.Head);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeftLeg", UnityEngine.HumanPartDof.LeftLeg);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RightLeg", UnityEngine.HumanPartDof.RightLeg);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeftArm", UnityEngine.HumanPartDof.LeftArm);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RightArm", UnityEngine.HumanPartDof.RightArm);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeftThumb", UnityEngine.HumanPartDof.LeftThumb);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeftIndex", UnityEngine.HumanPartDof.LeftIndex);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeftMiddle", UnityEngine.HumanPartDof.LeftMiddle);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeftRing", UnityEngine.HumanPartDof.LeftRing);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeftLittle", UnityEngine.HumanPartDof.LeftLittle);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RightThumb", UnityEngine.HumanPartDof.RightThumb);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RightIndex", UnityEngine.HumanPartDof.RightIndex);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RightMiddle", UnityEngine.HumanPartDof.RightMiddle);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RightRing", UnityEngine.HumanPartDof.RightRing);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RightLittle", UnityEngine.HumanPartDof.RightLittle);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LastHumanPartDof", UnityEngine.HumanPartDof.LastHumanPartDof);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.HumanPartDof), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineHumanPartDof(L, (UnityEngine.HumanPartDof)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Body"))
                {
                    translator.PushUnityEngineHumanPartDof(L, UnityEngine.HumanPartDof.Body);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Head"))
                {
                    translator.PushUnityEngineHumanPartDof(L, UnityEngine.HumanPartDof.Head);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LeftLeg"))
                {
                    translator.PushUnityEngineHumanPartDof(L, UnityEngine.HumanPartDof.LeftLeg);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RightLeg"))
                {
                    translator.PushUnityEngineHumanPartDof(L, UnityEngine.HumanPartDof.RightLeg);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LeftArm"))
                {
                    translator.PushUnityEngineHumanPartDof(L, UnityEngine.HumanPartDof.LeftArm);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RightArm"))
                {
                    translator.PushUnityEngineHumanPartDof(L, UnityEngine.HumanPartDof.RightArm);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LeftThumb"))
                {
                    translator.PushUnityEngineHumanPartDof(L, UnityEngine.HumanPartDof.LeftThumb);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LeftIndex"))
                {
                    translator.PushUnityEngineHumanPartDof(L, UnityEngine.HumanPartDof.LeftIndex);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LeftMiddle"))
                {
                    translator.PushUnityEngineHumanPartDof(L, UnityEngine.HumanPartDof.LeftMiddle);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LeftRing"))
                {
                    translator.PushUnityEngineHumanPartDof(L, UnityEngine.HumanPartDof.LeftRing);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LeftLittle"))
                {
                    translator.PushUnityEngineHumanPartDof(L, UnityEngine.HumanPartDof.LeftLittle);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RightThumb"))
                {
                    translator.PushUnityEngineHumanPartDof(L, UnityEngine.HumanPartDof.RightThumb);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RightIndex"))
                {
                    translator.PushUnityEngineHumanPartDof(L, UnityEngine.HumanPartDof.RightIndex);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RightMiddle"))
                {
                    translator.PushUnityEngineHumanPartDof(L, UnityEngine.HumanPartDof.RightMiddle);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RightRing"))
                {
                    translator.PushUnityEngineHumanPartDof(L, UnityEngine.HumanPartDof.RightRing);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RightLittle"))
                {
                    translator.PushUnityEngineHumanPartDof(L, UnityEngine.HumanPartDof.RightLittle);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LastHumanPartDof"))
                {
                    translator.PushUnityEngineHumanPartDof(L, UnityEngine.HumanPartDof.LastHumanPartDof);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.HumanPartDof!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.HumanPartDof! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineHumanBodyBonesWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.HumanBodyBones), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.HumanBodyBones), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.HumanBodyBones), L, null, 57, 0, 0);

            Utils.RegisterEnumType(L, typeof(UnityEngine.HumanBodyBones));

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.HumanBodyBones), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineHumanBodyBones(L, (UnityEngine.HumanBodyBones)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

                try
				{
                    translator.TranslateToEnumToTop(L, typeof(UnityEngine.HumanBodyBones), 1);
				}
				catch (System.Exception e)
				{
					return LuaAPI.luaL_error(L, "cast to " + typeof(UnityEngine.HumanBodyBones) + " exception:" + e);
				}

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.HumanBodyBones! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAvatarMaskBodyPartWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.AvatarMaskBodyPart), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.AvatarMaskBodyPart), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.AvatarMaskBodyPart), L, null, 15, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Root", UnityEngine.AvatarMaskBodyPart.Root);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Body", UnityEngine.AvatarMaskBodyPart.Body);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Head", UnityEngine.AvatarMaskBodyPart.Head);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeftLeg", UnityEngine.AvatarMaskBodyPart.LeftLeg);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RightLeg", UnityEngine.AvatarMaskBodyPart.RightLeg);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeftArm", UnityEngine.AvatarMaskBodyPart.LeftArm);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RightArm", UnityEngine.AvatarMaskBodyPart.RightArm);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeftFingers", UnityEngine.AvatarMaskBodyPart.LeftFingers);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RightFingers", UnityEngine.AvatarMaskBodyPart.RightFingers);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeftFootIK", UnityEngine.AvatarMaskBodyPart.LeftFootIK);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RightFootIK", UnityEngine.AvatarMaskBodyPart.RightFootIK);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeftHandIK", UnityEngine.AvatarMaskBodyPart.LeftHandIK);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RightHandIK", UnityEngine.AvatarMaskBodyPart.RightHandIK);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LastBodyPart", UnityEngine.AvatarMaskBodyPart.LastBodyPart);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.AvatarMaskBodyPart), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAvatarMaskBodyPart(L, (UnityEngine.AvatarMaskBodyPart)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Root"))
                {
                    translator.PushUnityEngineAvatarMaskBodyPart(L, UnityEngine.AvatarMaskBodyPart.Root);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Body"))
                {
                    translator.PushUnityEngineAvatarMaskBodyPart(L, UnityEngine.AvatarMaskBodyPart.Body);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Head"))
                {
                    translator.PushUnityEngineAvatarMaskBodyPart(L, UnityEngine.AvatarMaskBodyPart.Head);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LeftLeg"))
                {
                    translator.PushUnityEngineAvatarMaskBodyPart(L, UnityEngine.AvatarMaskBodyPart.LeftLeg);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RightLeg"))
                {
                    translator.PushUnityEngineAvatarMaskBodyPart(L, UnityEngine.AvatarMaskBodyPart.RightLeg);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LeftArm"))
                {
                    translator.PushUnityEngineAvatarMaskBodyPart(L, UnityEngine.AvatarMaskBodyPart.LeftArm);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RightArm"))
                {
                    translator.PushUnityEngineAvatarMaskBodyPart(L, UnityEngine.AvatarMaskBodyPart.RightArm);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LeftFingers"))
                {
                    translator.PushUnityEngineAvatarMaskBodyPart(L, UnityEngine.AvatarMaskBodyPart.LeftFingers);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RightFingers"))
                {
                    translator.PushUnityEngineAvatarMaskBodyPart(L, UnityEngine.AvatarMaskBodyPart.RightFingers);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LeftFootIK"))
                {
                    translator.PushUnityEngineAvatarMaskBodyPart(L, UnityEngine.AvatarMaskBodyPart.LeftFootIK);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RightFootIK"))
                {
                    translator.PushUnityEngineAvatarMaskBodyPart(L, UnityEngine.AvatarMaskBodyPart.RightFootIK);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LeftHandIK"))
                {
                    translator.PushUnityEngineAvatarMaskBodyPart(L, UnityEngine.AvatarMaskBodyPart.LeftHandIK);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RightHandIK"))
                {
                    translator.PushUnityEngineAvatarMaskBodyPart(L, UnityEngine.AvatarMaskBodyPart.RightHandIK);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LastBodyPart"))
                {
                    translator.PushUnityEngineAvatarMaskBodyPart(L, UnityEngine.AvatarMaskBodyPart.LastBodyPart);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.AvatarMaskBodyPart!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AvatarMaskBodyPart! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAnimationsAimConstraintWorldUpTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Animations.AimConstraint.WorldUpType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Animations.AimConstraint.WorldUpType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Animations.AimConstraint.WorldUpType), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SceneUp", UnityEngine.Animations.AimConstraint.WorldUpType.SceneUp);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ObjectUp", UnityEngine.Animations.AimConstraint.WorldUpType.ObjectUp);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ObjectRotationUp", UnityEngine.Animations.AimConstraint.WorldUpType.ObjectRotationUp);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vector", UnityEngine.Animations.AimConstraint.WorldUpType.Vector);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Animations.AimConstraint.WorldUpType.None);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Animations.AimConstraint.WorldUpType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAnimationsAimConstraintWorldUpType(L, (UnityEngine.Animations.AimConstraint.WorldUpType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "SceneUp"))
                {
                    translator.PushUnityEngineAnimationsAimConstraintWorldUpType(L, UnityEngine.Animations.AimConstraint.WorldUpType.SceneUp);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ObjectUp"))
                {
                    translator.PushUnityEngineAnimationsAimConstraintWorldUpType(L, UnityEngine.Animations.AimConstraint.WorldUpType.ObjectUp);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ObjectRotationUp"))
                {
                    translator.PushUnityEngineAnimationsAimConstraintWorldUpType(L, UnityEngine.Animations.AimConstraint.WorldUpType.ObjectRotationUp);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Vector"))
                {
                    translator.PushUnityEngineAnimationsAimConstraintWorldUpType(L, UnityEngine.Animations.AimConstraint.WorldUpType.Vector);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineAnimationsAimConstraintWorldUpType(L, UnityEngine.Animations.AimConstraint.WorldUpType.None);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Animations.AimConstraint.WorldUpType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Animations.AimConstraint.WorldUpType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAnimationsCustomStreamPropertyTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Animations.CustomStreamPropertyType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Animations.CustomStreamPropertyType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Animations.CustomStreamPropertyType), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Float", UnityEngine.Animations.CustomStreamPropertyType.Float);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Bool", UnityEngine.Animations.CustomStreamPropertyType.Bool);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Int", UnityEngine.Animations.CustomStreamPropertyType.Int);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Animations.CustomStreamPropertyType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAnimationsCustomStreamPropertyType(L, (UnityEngine.Animations.CustomStreamPropertyType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Float"))
                {
                    translator.PushUnityEngineAnimationsCustomStreamPropertyType(L, UnityEngine.Animations.CustomStreamPropertyType.Float);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Bool"))
                {
                    translator.PushUnityEngineAnimationsCustomStreamPropertyType(L, UnityEngine.Animations.CustomStreamPropertyType.Bool);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Int"))
                {
                    translator.PushUnityEngineAnimationsCustomStreamPropertyType(L, UnityEngine.Animations.CustomStreamPropertyType.Int);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Animations.CustomStreamPropertyType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Animations.CustomStreamPropertyType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAnimationsAxisWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Animations.Axis), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Animations.Axis), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Animations.Axis), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Animations.Axis.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "X", UnityEngine.Animations.Axis.X);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Y", UnityEngine.Animations.Axis.Y);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Z", UnityEngine.Animations.Axis.Z);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Animations.Axis), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAnimationsAxis(L, (UnityEngine.Animations.Axis)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineAnimationsAxis(L, UnityEngine.Animations.Axis.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "X"))
                {
                    translator.PushUnityEngineAnimationsAxis(L, UnityEngine.Animations.Axis.X);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Y"))
                {
                    translator.PushUnityEngineAnimationsAxis(L, UnityEngine.Animations.Axis.Y);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Z"))
                {
                    translator.PushUnityEngineAnimationsAxis(L, UnityEngine.Animations.Axis.Z);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Animations.Axis!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Animations.Axis! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAssetBundleLoadResultWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.AssetBundleLoadResult), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.AssetBundleLoadResult), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.AssetBundleLoadResult), L, null, 15, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Success", UnityEngine.AssetBundleLoadResult.Success);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Cancelled", UnityEngine.AssetBundleLoadResult.Cancelled);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NotMatchingCrc", UnityEngine.AssetBundleLoadResult.NotMatchingCrc);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FailedCache", UnityEngine.AssetBundleLoadResult.FailedCache);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NotValidAssetBundle", UnityEngine.AssetBundleLoadResult.NotValidAssetBundle);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NoSerializedData", UnityEngine.AssetBundleLoadResult.NoSerializedData);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NotCompatible", UnityEngine.AssetBundleLoadResult.NotCompatible);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AlreadyLoaded", UnityEngine.AssetBundleLoadResult.AlreadyLoaded);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FailedRead", UnityEngine.AssetBundleLoadResult.FailedRead);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FailedDecompression", UnityEngine.AssetBundleLoadResult.FailedDecompression);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FailedWrite", UnityEngine.AssetBundleLoadResult.FailedWrite);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FailedDeleteRecompressionTarget", UnityEngine.AssetBundleLoadResult.FailedDeleteRecompressionTarget);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RecompressionTargetIsLoaded", UnityEngine.AssetBundleLoadResult.RecompressionTargetIsLoaded);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RecompressionTargetExistsButNotArchive", UnityEngine.AssetBundleLoadResult.RecompressionTargetExistsButNotArchive);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.AssetBundleLoadResult), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAssetBundleLoadResult(L, (UnityEngine.AssetBundleLoadResult)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Success"))
                {
                    translator.PushUnityEngineAssetBundleLoadResult(L, UnityEngine.AssetBundleLoadResult.Success);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Cancelled"))
                {
                    translator.PushUnityEngineAssetBundleLoadResult(L, UnityEngine.AssetBundleLoadResult.Cancelled);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NotMatchingCrc"))
                {
                    translator.PushUnityEngineAssetBundleLoadResult(L, UnityEngine.AssetBundleLoadResult.NotMatchingCrc);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FailedCache"))
                {
                    translator.PushUnityEngineAssetBundleLoadResult(L, UnityEngine.AssetBundleLoadResult.FailedCache);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NotValidAssetBundle"))
                {
                    translator.PushUnityEngineAssetBundleLoadResult(L, UnityEngine.AssetBundleLoadResult.NotValidAssetBundle);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NoSerializedData"))
                {
                    translator.PushUnityEngineAssetBundleLoadResult(L, UnityEngine.AssetBundleLoadResult.NoSerializedData);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NotCompatible"))
                {
                    translator.PushUnityEngineAssetBundleLoadResult(L, UnityEngine.AssetBundleLoadResult.NotCompatible);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AlreadyLoaded"))
                {
                    translator.PushUnityEngineAssetBundleLoadResult(L, UnityEngine.AssetBundleLoadResult.AlreadyLoaded);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FailedRead"))
                {
                    translator.PushUnityEngineAssetBundleLoadResult(L, UnityEngine.AssetBundleLoadResult.FailedRead);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FailedDecompression"))
                {
                    translator.PushUnityEngineAssetBundleLoadResult(L, UnityEngine.AssetBundleLoadResult.FailedDecompression);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FailedWrite"))
                {
                    translator.PushUnityEngineAssetBundleLoadResult(L, UnityEngine.AssetBundleLoadResult.FailedWrite);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FailedDeleteRecompressionTarget"))
                {
                    translator.PushUnityEngineAssetBundleLoadResult(L, UnityEngine.AssetBundleLoadResult.FailedDeleteRecompressionTarget);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RecompressionTargetIsLoaded"))
                {
                    translator.PushUnityEngineAssetBundleLoadResult(L, UnityEngine.AssetBundleLoadResult.RecompressionTargetIsLoaded);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RecompressionTargetExistsButNotArchive"))
                {
                    translator.PushUnityEngineAssetBundleLoadResult(L, UnityEngine.AssetBundleLoadResult.RecompressionTargetExistsButNotArchive);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.AssetBundleLoadResult!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AssetBundleLoadResult! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCompressionTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.CompressionType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.CompressionType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.CompressionType), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.CompressionType.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Lzma", UnityEngine.CompressionType.Lzma);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Lz4", UnityEngine.CompressionType.Lz4);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Lz4HC", UnityEngine.CompressionType.Lz4HC);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.CompressionType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCompressionType(L, (UnityEngine.CompressionType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineCompressionType(L, UnityEngine.CompressionType.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Lzma"))
                {
                    translator.PushUnityEngineCompressionType(L, UnityEngine.CompressionType.Lzma);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Lz4"))
                {
                    translator.PushUnityEngineCompressionType(L, UnityEngine.CompressionType.Lz4);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Lz4HC"))
                {
                    translator.PushUnityEngineCompressionType(L, UnityEngine.CompressionType.Lz4HC);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.CompressionType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.CompressionType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCompressionLevelWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.CompressionLevel), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.CompressionLevel), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.CompressionLevel), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.CompressionLevel.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fastest", UnityEngine.CompressionLevel.Fastest);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fast", UnityEngine.CompressionLevel.Fast);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", UnityEngine.CompressionLevel.Normal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "High", UnityEngine.CompressionLevel.High);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Maximum", UnityEngine.CompressionLevel.Maximum);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.CompressionLevel), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCompressionLevel(L, (UnityEngine.CompressionLevel)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineCompressionLevel(L, UnityEngine.CompressionLevel.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Fastest"))
                {
                    translator.PushUnityEngineCompressionLevel(L, UnityEngine.CompressionLevel.Fastest);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Fast"))
                {
                    translator.PushUnityEngineCompressionLevel(L, UnityEngine.CompressionLevel.Fast);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
                {
                    translator.PushUnityEngineCompressionLevel(L, UnityEngine.CompressionLevel.Normal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "High"))
                {
                    translator.PushUnityEngineCompressionLevel(L, UnityEngine.CompressionLevel.High);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Maximum"))
                {
                    translator.PushUnityEngineCompressionLevel(L, UnityEngine.CompressionLevel.Maximum);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.CompressionLevel!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.CompressionLevel! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAudioSpeakerModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.AudioSpeakerMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.AudioSpeakerMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.AudioSpeakerMode), L, null, 9, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mono", UnityEngine.AudioSpeakerMode.Mono);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Stereo", UnityEngine.AudioSpeakerMode.Stereo);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Quad", UnityEngine.AudioSpeakerMode.Quad);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Surround", UnityEngine.AudioSpeakerMode.Surround);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mode5point1", UnityEngine.AudioSpeakerMode.Mode5point1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mode7point1", UnityEngine.AudioSpeakerMode.Mode7point1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Prologic", UnityEngine.AudioSpeakerMode.Prologic);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.AudioSpeakerMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAudioSpeakerMode(L, (UnityEngine.AudioSpeakerMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Mono"))
                {
                    translator.PushUnityEngineAudioSpeakerMode(L, UnityEngine.AudioSpeakerMode.Mono);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Stereo"))
                {
                    translator.PushUnityEngineAudioSpeakerMode(L, UnityEngine.AudioSpeakerMode.Stereo);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Quad"))
                {
                    translator.PushUnityEngineAudioSpeakerMode(L, UnityEngine.AudioSpeakerMode.Quad);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Surround"))
                {
                    translator.PushUnityEngineAudioSpeakerMode(L, UnityEngine.AudioSpeakerMode.Surround);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Mode5point1"))
                {
                    translator.PushUnityEngineAudioSpeakerMode(L, UnityEngine.AudioSpeakerMode.Mode5point1);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Mode7point1"))
                {
                    translator.PushUnityEngineAudioSpeakerMode(L, UnityEngine.AudioSpeakerMode.Mode7point1);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Prologic"))
                {
                    translator.PushUnityEngineAudioSpeakerMode(L, UnityEngine.AudioSpeakerMode.Prologic);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.AudioSpeakerMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AudioSpeakerMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAudioDataLoadStateWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.AudioDataLoadState), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.AudioDataLoadState), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.AudioDataLoadState), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Unloaded", UnityEngine.AudioDataLoadState.Unloaded);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Loading", UnityEngine.AudioDataLoadState.Loading);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Loaded", UnityEngine.AudioDataLoadState.Loaded);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Failed", UnityEngine.AudioDataLoadState.Failed);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.AudioDataLoadState), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAudioDataLoadState(L, (UnityEngine.AudioDataLoadState)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Unloaded"))
                {
                    translator.PushUnityEngineAudioDataLoadState(L, UnityEngine.AudioDataLoadState.Unloaded);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Loading"))
                {
                    translator.PushUnityEngineAudioDataLoadState(L, UnityEngine.AudioDataLoadState.Loading);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Loaded"))
                {
                    translator.PushUnityEngineAudioDataLoadState(L, UnityEngine.AudioDataLoadState.Loaded);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Failed"))
                {
                    translator.PushUnityEngineAudioDataLoadState(L, UnityEngine.AudioDataLoadState.Failed);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.AudioDataLoadState!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AudioDataLoadState! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAudioCompressionFormatWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.AudioCompressionFormat), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.AudioCompressionFormat), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.AudioCompressionFormat), L, null, 11, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PCM", UnityEngine.AudioCompressionFormat.PCM);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vorbis", UnityEngine.AudioCompressionFormat.Vorbis);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ADPCM", UnityEngine.AudioCompressionFormat.ADPCM);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MP3", UnityEngine.AudioCompressionFormat.MP3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VAG", UnityEngine.AudioCompressionFormat.VAG);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HEVAG", UnityEngine.AudioCompressionFormat.HEVAG);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "XMA", UnityEngine.AudioCompressionFormat.XMA);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AAC", UnityEngine.AudioCompressionFormat.AAC);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GCADPCM", UnityEngine.AudioCompressionFormat.GCADPCM);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ATRAC9", UnityEngine.AudioCompressionFormat.ATRAC9);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.AudioCompressionFormat), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAudioCompressionFormat(L, (UnityEngine.AudioCompressionFormat)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "PCM"))
                {
                    translator.PushUnityEngineAudioCompressionFormat(L, UnityEngine.AudioCompressionFormat.PCM);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Vorbis"))
                {
                    translator.PushUnityEngineAudioCompressionFormat(L, UnityEngine.AudioCompressionFormat.Vorbis);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ADPCM"))
                {
                    translator.PushUnityEngineAudioCompressionFormat(L, UnityEngine.AudioCompressionFormat.ADPCM);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MP3"))
                {
                    translator.PushUnityEngineAudioCompressionFormat(L, UnityEngine.AudioCompressionFormat.MP3);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "VAG"))
                {
                    translator.PushUnityEngineAudioCompressionFormat(L, UnityEngine.AudioCompressionFormat.VAG);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "HEVAG"))
                {
                    translator.PushUnityEngineAudioCompressionFormat(L, UnityEngine.AudioCompressionFormat.HEVAG);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "XMA"))
                {
                    translator.PushUnityEngineAudioCompressionFormat(L, UnityEngine.AudioCompressionFormat.XMA);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AAC"))
                {
                    translator.PushUnityEngineAudioCompressionFormat(L, UnityEngine.AudioCompressionFormat.AAC);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "GCADPCM"))
                {
                    translator.PushUnityEngineAudioCompressionFormat(L, UnityEngine.AudioCompressionFormat.GCADPCM);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ATRAC9"))
                {
                    translator.PushUnityEngineAudioCompressionFormat(L, UnityEngine.AudioCompressionFormat.ATRAC9);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.AudioCompressionFormat!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AudioCompressionFormat! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAudioClipLoadTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.AudioClipLoadType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.AudioClipLoadType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.AudioClipLoadType), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DecompressOnLoad", UnityEngine.AudioClipLoadType.DecompressOnLoad);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CompressedInMemory", UnityEngine.AudioClipLoadType.CompressedInMemory);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Streaming", UnityEngine.AudioClipLoadType.Streaming);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.AudioClipLoadType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAudioClipLoadType(L, (UnityEngine.AudioClipLoadType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "DecompressOnLoad"))
                {
                    translator.PushUnityEngineAudioClipLoadType(L, UnityEngine.AudioClipLoadType.DecompressOnLoad);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CompressedInMemory"))
                {
                    translator.PushUnityEngineAudioClipLoadType(L, UnityEngine.AudioClipLoadType.CompressedInMemory);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Streaming"))
                {
                    translator.PushUnityEngineAudioClipLoadType(L, UnityEngine.AudioClipLoadType.Streaming);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.AudioClipLoadType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AudioClipLoadType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAudioVelocityUpdateModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.AudioVelocityUpdateMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.AudioVelocityUpdateMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.AudioVelocityUpdateMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Auto", UnityEngine.AudioVelocityUpdateMode.Auto);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fixed", UnityEngine.AudioVelocityUpdateMode.Fixed);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Dynamic", UnityEngine.AudioVelocityUpdateMode.Dynamic);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.AudioVelocityUpdateMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAudioVelocityUpdateMode(L, (UnityEngine.AudioVelocityUpdateMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Auto"))
                {
                    translator.PushUnityEngineAudioVelocityUpdateMode(L, UnityEngine.AudioVelocityUpdateMode.Auto);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Fixed"))
                {
                    translator.PushUnityEngineAudioVelocityUpdateMode(L, UnityEngine.AudioVelocityUpdateMode.Fixed);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Dynamic"))
                {
                    translator.PushUnityEngineAudioVelocityUpdateMode(L, UnityEngine.AudioVelocityUpdateMode.Dynamic);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.AudioVelocityUpdateMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AudioVelocityUpdateMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAudioRolloffModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.AudioRolloffMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.AudioRolloffMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.AudioRolloffMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Logarithmic", UnityEngine.AudioRolloffMode.Logarithmic);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Linear", UnityEngine.AudioRolloffMode.Linear);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Custom", UnityEngine.AudioRolloffMode.Custom);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.AudioRolloffMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAudioRolloffMode(L, (UnityEngine.AudioRolloffMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Logarithmic"))
                {
                    translator.PushUnityEngineAudioRolloffMode(L, UnityEngine.AudioRolloffMode.Logarithmic);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Linear"))
                {
                    translator.PushUnityEngineAudioRolloffMode(L, UnityEngine.AudioRolloffMode.Linear);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Custom"))
                {
                    translator.PushUnityEngineAudioRolloffMode(L, UnityEngine.AudioRolloffMode.Custom);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.AudioRolloffMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AudioRolloffMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAudioSourceCurveTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.AudioSourceCurveType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.AudioSourceCurveType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.AudioSourceCurveType), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CustomRolloff", UnityEngine.AudioSourceCurveType.CustomRolloff);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SpatialBlend", UnityEngine.AudioSourceCurveType.SpatialBlend);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReverbZoneMix", UnityEngine.AudioSourceCurveType.ReverbZoneMix);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Spread", UnityEngine.AudioSourceCurveType.Spread);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.AudioSourceCurveType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAudioSourceCurveType(L, (UnityEngine.AudioSourceCurveType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "CustomRolloff"))
                {
                    translator.PushUnityEngineAudioSourceCurveType(L, UnityEngine.AudioSourceCurveType.CustomRolloff);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SpatialBlend"))
                {
                    translator.PushUnityEngineAudioSourceCurveType(L, UnityEngine.AudioSourceCurveType.SpatialBlend);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ReverbZoneMix"))
                {
                    translator.PushUnityEngineAudioSourceCurveType(L, UnityEngine.AudioSourceCurveType.ReverbZoneMix);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Spread"))
                {
                    translator.PushUnityEngineAudioSourceCurveType(L, UnityEngine.AudioSourceCurveType.Spread);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.AudioSourceCurveType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AudioSourceCurveType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAudioReverbPresetWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.AudioReverbPreset), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.AudioReverbPreset), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.AudioReverbPreset), L, null, 29, 0, 0);

            Utils.RegisterEnumType(L, typeof(UnityEngine.AudioReverbPreset));

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.AudioReverbPreset), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAudioReverbPreset(L, (UnityEngine.AudioReverbPreset)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

                try
				{
                    translator.TranslateToEnumToTop(L, typeof(UnityEngine.AudioReverbPreset), 1);
				}
				catch (System.Exception e)
				{
					return LuaAPI.luaL_error(L, "cast to " + typeof(UnityEngine.AudioReverbPreset) + " exception:" + e);
				}

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AudioReverbPreset! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineWebCamFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.WebCamFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.WebCamFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.WebCamFlags), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FrontFacing", UnityEngine.WebCamFlags.FrontFacing);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AutoFocusPointSupported", UnityEngine.WebCamFlags.AutoFocusPointSupported);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.WebCamFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineWebCamFlags(L, (UnityEngine.WebCamFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "FrontFacing"))
                {
                    translator.PushUnityEngineWebCamFlags(L, UnityEngine.WebCamFlags.FrontFacing);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AutoFocusPointSupported"))
                {
                    translator.PushUnityEngineWebCamFlags(L, UnityEngine.WebCamFlags.AutoFocusPointSupported);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.WebCamFlags!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.WebCamFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineWebCamKindWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.WebCamKind), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.WebCamKind), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.WebCamKind), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WideAngle", UnityEngine.WebCamKind.WideAngle);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Telephoto", UnityEngine.WebCamKind.Telephoto);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ColorAndDepth", UnityEngine.WebCamKind.ColorAndDepth);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UltraWideAngle", UnityEngine.WebCamKind.UltraWideAngle);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.WebCamKind), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineWebCamKind(L, (UnityEngine.WebCamKind)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "WideAngle"))
                {
                    translator.PushUnityEngineWebCamKind(L, UnityEngine.WebCamKind.WideAngle);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Telephoto"))
                {
                    translator.PushUnityEngineWebCamKind(L, UnityEngine.WebCamKind.Telephoto);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ColorAndDepth"))
                {
                    translator.PushUnityEngineWebCamKind(L, UnityEngine.WebCamKind.ColorAndDepth);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UltraWideAngle"))
                {
                    translator.PushUnityEngineWebCamKind(L, UnityEngine.WebCamKind.UltraWideAngle);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.WebCamKind!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.WebCamKind! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAudioAudioMixerUpdateModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Audio.AudioMixerUpdateMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Audio.AudioMixerUpdateMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Audio.AudioMixerUpdateMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", UnityEngine.Audio.AudioMixerUpdateMode.Normal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnscaledTime", UnityEngine.Audio.AudioMixerUpdateMode.UnscaledTime);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Audio.AudioMixerUpdateMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAudioAudioMixerUpdateMode(L, (UnityEngine.Audio.AudioMixerUpdateMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
                {
                    translator.PushUnityEngineAudioAudioMixerUpdateMode(L, UnityEngine.Audio.AudioMixerUpdateMode.Normal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UnscaledTime"))
                {
                    translator.PushUnityEngineAudioAudioMixerUpdateMode(L, UnityEngine.Audio.AudioMixerUpdateMode.UnscaledTime);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Audio.AudioMixerUpdateMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Audio.AudioMixerUpdateMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityProfilingProfilerCategoryFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Unity.Profiling.ProfilerCategoryFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Unity.Profiling.ProfilerCategoryFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Unity.Profiling.ProfilerCategoryFlags), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", Unity.Profiling.ProfilerCategoryFlags.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Builtin", Unity.Profiling.ProfilerCategoryFlags.Builtin);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Unity.Profiling.ProfilerCategoryFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityProfilingProfilerCategoryFlags(L, (Unity.Profiling.ProfilerCategoryFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityProfilingProfilerCategoryFlags(L, Unity.Profiling.ProfilerCategoryFlags.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Builtin"))
                {
                    translator.PushUnityProfilingProfilerCategoryFlags(L, Unity.Profiling.ProfilerCategoryFlags.Builtin);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Unity.Profiling.ProfilerCategoryFlags!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Unity.Profiling.ProfilerCategoryFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityProfilingProfilerMarkerDataUnitWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Unity.Profiling.ProfilerMarkerDataUnit), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Unity.Profiling.ProfilerMarkerDataUnit), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Unity.Profiling.ProfilerMarkerDataUnit), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Undefined", Unity.Profiling.ProfilerMarkerDataUnit.Undefined);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TimeNanoseconds", Unity.Profiling.ProfilerMarkerDataUnit.TimeNanoseconds);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Bytes", Unity.Profiling.ProfilerMarkerDataUnit.Bytes);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Count", Unity.Profiling.ProfilerMarkerDataUnit.Count);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Percent", Unity.Profiling.ProfilerMarkerDataUnit.Percent);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FrequencyHz", Unity.Profiling.ProfilerMarkerDataUnit.FrequencyHz);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Unity.Profiling.ProfilerMarkerDataUnit), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityProfilingProfilerMarkerDataUnit(L, (Unity.Profiling.ProfilerMarkerDataUnit)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Undefined"))
                {
                    translator.PushUnityProfilingProfilerMarkerDataUnit(L, Unity.Profiling.ProfilerMarkerDataUnit.Undefined);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TimeNanoseconds"))
                {
                    translator.PushUnityProfilingProfilerMarkerDataUnit(L, Unity.Profiling.ProfilerMarkerDataUnit.TimeNanoseconds);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Bytes"))
                {
                    translator.PushUnityProfilingProfilerMarkerDataUnit(L, Unity.Profiling.ProfilerMarkerDataUnit.Bytes);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Count"))
                {
                    translator.PushUnityProfilingProfilerMarkerDataUnit(L, Unity.Profiling.ProfilerMarkerDataUnit.Count);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Percent"))
                {
                    translator.PushUnityProfilingProfilerMarkerDataUnit(L, Unity.Profiling.ProfilerMarkerDataUnit.Percent);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FrequencyHz"))
                {
                    translator.PushUnityProfilingProfilerMarkerDataUnit(L, Unity.Profiling.ProfilerMarkerDataUnit.FrequencyHz);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Unity.Profiling.ProfilerMarkerDataUnit!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Unity.Profiling.ProfilerMarkerDataUnit! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityProfilingProfilerCounterOptionsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Unity.Profiling.ProfilerCounterOptions), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Unity.Profiling.ProfilerCounterOptions), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Unity.Profiling.ProfilerCounterOptions), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", Unity.Profiling.ProfilerCounterOptions.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FlushOnEndOfFrame", Unity.Profiling.ProfilerCounterOptions.FlushOnEndOfFrame);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ResetToZeroOnFlush", Unity.Profiling.ProfilerCounterOptions.ResetToZeroOnFlush);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Unity.Profiling.ProfilerCounterOptions), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityProfilingProfilerCounterOptions(L, (Unity.Profiling.ProfilerCounterOptions)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityProfilingProfilerCounterOptions(L, Unity.Profiling.ProfilerCounterOptions.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FlushOnEndOfFrame"))
                {
                    translator.PushUnityProfilingProfilerCounterOptions(L, Unity.Profiling.ProfilerCounterOptions.FlushOnEndOfFrame);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ResetToZeroOnFlush"))
                {
                    translator.PushUnityProfilingProfilerCounterOptions(L, Unity.Profiling.ProfilerCounterOptions.ResetToZeroOnFlush);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Unity.Profiling.ProfilerCounterOptions!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Unity.Profiling.ProfilerCounterOptions! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityProfilingProfilerRecorderOptionsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Unity.Profiling.ProfilerRecorderOptions), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Unity.Profiling.ProfilerRecorderOptions), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Unity.Profiling.ProfilerRecorderOptions), L, null, 8, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", Unity.Profiling.ProfilerRecorderOptions.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StartImmediately", Unity.Profiling.ProfilerRecorderOptions.StartImmediately);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KeepAliveDuringDomainReload", Unity.Profiling.ProfilerRecorderOptions.KeepAliveDuringDomainReload);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CollectOnlyOnCurrentThread", Unity.Profiling.ProfilerRecorderOptions.CollectOnlyOnCurrentThread);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WrapAroundWhenCapacityReached", Unity.Profiling.ProfilerRecorderOptions.WrapAroundWhenCapacityReached);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SumAllSamplesInFrame", Unity.Profiling.ProfilerRecorderOptions.SumAllSamplesInFrame);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Default", Unity.Profiling.ProfilerRecorderOptions.Default);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Unity.Profiling.ProfilerRecorderOptions), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityProfilingProfilerRecorderOptions(L, (Unity.Profiling.ProfilerRecorderOptions)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityProfilingProfilerRecorderOptions(L, Unity.Profiling.ProfilerRecorderOptions.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "StartImmediately"))
                {
                    translator.PushUnityProfilingProfilerRecorderOptions(L, Unity.Profiling.ProfilerRecorderOptions.StartImmediately);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "KeepAliveDuringDomainReload"))
                {
                    translator.PushUnityProfilingProfilerRecorderOptions(L, Unity.Profiling.ProfilerRecorderOptions.KeepAliveDuringDomainReload);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CollectOnlyOnCurrentThread"))
                {
                    translator.PushUnityProfilingProfilerRecorderOptions(L, Unity.Profiling.ProfilerRecorderOptions.CollectOnlyOnCurrentThread);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "WrapAroundWhenCapacityReached"))
                {
                    translator.PushUnityProfilingProfilerRecorderOptions(L, Unity.Profiling.ProfilerRecorderOptions.WrapAroundWhenCapacityReached);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SumAllSamplesInFrame"))
                {
                    translator.PushUnityProfilingProfilerRecorderOptions(L, Unity.Profiling.ProfilerRecorderOptions.SumAllSamplesInFrame);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Default"))
                {
                    translator.PushUnityProfilingProfilerRecorderOptions(L, Unity.Profiling.ProfilerRecorderOptions.Default);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Unity.Profiling.ProfilerRecorderOptions!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Unity.Profiling.ProfilerRecorderOptions! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityProfilingLowLevelMarkerFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Unity.Profiling.LowLevel.MarkerFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Unity.Profiling.LowLevel.MarkerFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Unity.Profiling.LowLevel.MarkerFlags), L, null, 8, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Default", Unity.Profiling.LowLevel.MarkerFlags.Default);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Script", Unity.Profiling.LowLevel.MarkerFlags.Script);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ScriptInvoke", Unity.Profiling.LowLevel.MarkerFlags.ScriptInvoke);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ScriptDeepProfiler", Unity.Profiling.LowLevel.MarkerFlags.ScriptDeepProfiler);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AvailabilityEditor", Unity.Profiling.LowLevel.MarkerFlags.AvailabilityEditor);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Warning", Unity.Profiling.LowLevel.MarkerFlags.Warning);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Counter", Unity.Profiling.LowLevel.MarkerFlags.Counter);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Unity.Profiling.LowLevel.MarkerFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityProfilingLowLevelMarkerFlags(L, (Unity.Profiling.LowLevel.MarkerFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Default"))
                {
                    translator.PushUnityProfilingLowLevelMarkerFlags(L, Unity.Profiling.LowLevel.MarkerFlags.Default);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Script"))
                {
                    translator.PushUnityProfilingLowLevelMarkerFlags(L, Unity.Profiling.LowLevel.MarkerFlags.Script);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ScriptInvoke"))
                {
                    translator.PushUnityProfilingLowLevelMarkerFlags(L, Unity.Profiling.LowLevel.MarkerFlags.ScriptInvoke);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ScriptDeepProfiler"))
                {
                    translator.PushUnityProfilingLowLevelMarkerFlags(L, Unity.Profiling.LowLevel.MarkerFlags.ScriptDeepProfiler);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AvailabilityEditor"))
                {
                    translator.PushUnityProfilingLowLevelMarkerFlags(L, Unity.Profiling.LowLevel.MarkerFlags.AvailabilityEditor);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Warning"))
                {
                    translator.PushUnityProfilingLowLevelMarkerFlags(L, Unity.Profiling.LowLevel.MarkerFlags.Warning);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Counter"))
                {
                    translator.PushUnityProfilingLowLevelMarkerFlags(L, Unity.Profiling.LowLevel.MarkerFlags.Counter);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Unity.Profiling.LowLevel.MarkerFlags!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Unity.Profiling.LowLevel.MarkerFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityProfilingLowLevelProfilerMarkerDataTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Unity.Profiling.LowLevel.ProfilerMarkerDataType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Unity.Profiling.LowLevel.ProfilerMarkerDataType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Unity.Profiling.LowLevel.ProfilerMarkerDataType), L, null, 9, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Int32", Unity.Profiling.LowLevel.ProfilerMarkerDataType.Int32);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UInt32", Unity.Profiling.LowLevel.ProfilerMarkerDataType.UInt32);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Int64", Unity.Profiling.LowLevel.ProfilerMarkerDataType.Int64);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UInt64", Unity.Profiling.LowLevel.ProfilerMarkerDataType.UInt64);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Float", Unity.Profiling.LowLevel.ProfilerMarkerDataType.Float);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Double", Unity.Profiling.LowLevel.ProfilerMarkerDataType.Double);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "String16", Unity.Profiling.LowLevel.ProfilerMarkerDataType.String16);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Blob8", Unity.Profiling.LowLevel.ProfilerMarkerDataType.Blob8);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Unity.Profiling.LowLevel.ProfilerMarkerDataType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityProfilingLowLevelProfilerMarkerDataType(L, (Unity.Profiling.LowLevel.ProfilerMarkerDataType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Int32"))
                {
                    translator.PushUnityProfilingLowLevelProfilerMarkerDataType(L, Unity.Profiling.LowLevel.ProfilerMarkerDataType.Int32);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UInt32"))
                {
                    translator.PushUnityProfilingLowLevelProfilerMarkerDataType(L, Unity.Profiling.LowLevel.ProfilerMarkerDataType.UInt32);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Int64"))
                {
                    translator.PushUnityProfilingLowLevelProfilerMarkerDataType(L, Unity.Profiling.LowLevel.ProfilerMarkerDataType.Int64);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UInt64"))
                {
                    translator.PushUnityProfilingLowLevelProfilerMarkerDataType(L, Unity.Profiling.LowLevel.ProfilerMarkerDataType.UInt64);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Float"))
                {
                    translator.PushUnityProfilingLowLevelProfilerMarkerDataType(L, Unity.Profiling.LowLevel.ProfilerMarkerDataType.Float);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Double"))
                {
                    translator.PushUnityProfilingLowLevelProfilerMarkerDataType(L, Unity.Profiling.LowLevel.ProfilerMarkerDataType.Double);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "String16"))
                {
                    translator.PushUnityProfilingLowLevelProfilerMarkerDataType(L, Unity.Profiling.LowLevel.ProfilerMarkerDataType.String16);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Blob8"))
                {
                    translator.PushUnityProfilingLowLevelProfilerMarkerDataType(L, Unity.Profiling.LowLevel.ProfilerMarkerDataType.Blob8);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Unity.Profiling.LowLevel.ProfilerMarkerDataType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Unity.Profiling.LowLevel.ProfilerMarkerDataType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityRenderingHybridV2DOTSInstancingPropertyTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Unity.Rendering.HybridV2.DOTSInstancingPropertyType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Unity.Rendering.HybridV2.DOTSInstancingPropertyType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Unity.Rendering.HybridV2.DOTSInstancingPropertyType), L, null, 9, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Unknown", Unity.Rendering.HybridV2.DOTSInstancingPropertyType.Unknown);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Float", Unity.Rendering.HybridV2.DOTSInstancingPropertyType.Float);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Half", Unity.Rendering.HybridV2.DOTSInstancingPropertyType.Half);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Int", Unity.Rendering.HybridV2.DOTSInstancingPropertyType.Int);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Short", Unity.Rendering.HybridV2.DOTSInstancingPropertyType.Short);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Uint", Unity.Rendering.HybridV2.DOTSInstancingPropertyType.Uint);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Bool", Unity.Rendering.HybridV2.DOTSInstancingPropertyType.Bool);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Struct", Unity.Rendering.HybridV2.DOTSInstancingPropertyType.Struct);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Unity.Rendering.HybridV2.DOTSInstancingPropertyType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityRenderingHybridV2DOTSInstancingPropertyType(L, (Unity.Rendering.HybridV2.DOTSInstancingPropertyType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Unknown"))
                {
                    translator.PushUnityRenderingHybridV2DOTSInstancingPropertyType(L, Unity.Rendering.HybridV2.DOTSInstancingPropertyType.Unknown);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Float"))
                {
                    translator.PushUnityRenderingHybridV2DOTSInstancingPropertyType(L, Unity.Rendering.HybridV2.DOTSInstancingPropertyType.Float);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Half"))
                {
                    translator.PushUnityRenderingHybridV2DOTSInstancingPropertyType(L, Unity.Rendering.HybridV2.DOTSInstancingPropertyType.Half);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Int"))
                {
                    translator.PushUnityRenderingHybridV2DOTSInstancingPropertyType(L, Unity.Rendering.HybridV2.DOTSInstancingPropertyType.Int);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Short"))
                {
                    translator.PushUnityRenderingHybridV2DOTSInstancingPropertyType(L, Unity.Rendering.HybridV2.DOTSInstancingPropertyType.Short);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Uint"))
                {
                    translator.PushUnityRenderingHybridV2DOTSInstancingPropertyType(L, Unity.Rendering.HybridV2.DOTSInstancingPropertyType.Uint);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Bool"))
                {
                    translator.PushUnityRenderingHybridV2DOTSInstancingPropertyType(L, Unity.Rendering.HybridV2.DOTSInstancingPropertyType.Bool);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Struct"))
                {
                    translator.PushUnityRenderingHybridV2DOTSInstancingPropertyType(L, Unity.Rendering.HybridV2.DOTSInstancingPropertyType.Struct);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Unity.Rendering.HybridV2.DOTSInstancingPropertyType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Unity.Rendering.HybridV2.DOTSInstancingPropertyType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityCollectionsAllocatorWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Unity.Collections.Allocator), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Unity.Collections.Allocator), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Unity.Collections.Allocator), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Invalid", Unity.Collections.Allocator.Invalid);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", Unity.Collections.Allocator.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Temp", Unity.Collections.Allocator.Temp);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TempJob", Unity.Collections.Allocator.TempJob);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Persistent", Unity.Collections.Allocator.Persistent);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AudioKernel", Unity.Collections.Allocator.AudioKernel);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Unity.Collections.Allocator), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityCollectionsAllocator(L, (Unity.Collections.Allocator)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Invalid"))
                {
                    translator.PushUnityCollectionsAllocator(L, Unity.Collections.Allocator.Invalid);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityCollectionsAllocator(L, Unity.Collections.Allocator.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Temp"))
                {
                    translator.PushUnityCollectionsAllocator(L, Unity.Collections.Allocator.Temp);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TempJob"))
                {
                    translator.PushUnityCollectionsAllocator(L, Unity.Collections.Allocator.TempJob);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Persistent"))
                {
                    translator.PushUnityCollectionsAllocator(L, Unity.Collections.Allocator.Persistent);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AudioKernel"))
                {
                    translator.PushUnityCollectionsAllocator(L, Unity.Collections.Allocator.AudioKernel);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Unity.Collections.Allocator!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Unity.Collections.Allocator! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityCollectionsNativeArrayOptionsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(Unity.Collections.NativeArrayOptions), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(Unity.Collections.NativeArrayOptions), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(Unity.Collections.NativeArrayOptions), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UninitializedMemory", Unity.Collections.NativeArrayOptions.UninitializedMemory);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ClearMemory", Unity.Collections.NativeArrayOptions.ClearMemory);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(Unity.Collections.NativeArrayOptions), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityCollectionsNativeArrayOptions(L, (Unity.Collections.NativeArrayOptions)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "UninitializedMemory"))
                {
                    translator.PushUnityCollectionsNativeArrayOptions(L, Unity.Collections.NativeArrayOptions.UninitializedMemory);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ClearMemory"))
                {
                    translator.PushUnityCollectionsNativeArrayOptions(L, Unity.Collections.NativeArrayOptions.ClearMemory);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for Unity.Collections.NativeArrayOptions!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for Unity.Collections.NativeArrayOptions! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class JetBrainsAnnotationsImplicitUseKindFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(JetBrains.Annotations.ImplicitUseKindFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(JetBrains.Annotations.ImplicitUseKindFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(JetBrains.Annotations.ImplicitUseKindFlags), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Default", JetBrains.Annotations.ImplicitUseKindFlags.Default);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Access", JetBrains.Annotations.ImplicitUseKindFlags.Access);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Assign", JetBrains.Annotations.ImplicitUseKindFlags.Assign);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "InstantiatedWithFixedConstructorSignature", JetBrains.Annotations.ImplicitUseKindFlags.InstantiatedWithFixedConstructorSignature);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "InstantiatedNoFixedConstructorSignature", JetBrains.Annotations.ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(JetBrains.Annotations.ImplicitUseKindFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushJetBrainsAnnotationsImplicitUseKindFlags(L, (JetBrains.Annotations.ImplicitUseKindFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Default"))
                {
                    translator.PushJetBrainsAnnotationsImplicitUseKindFlags(L, JetBrains.Annotations.ImplicitUseKindFlags.Default);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Access"))
                {
                    translator.PushJetBrainsAnnotationsImplicitUseKindFlags(L, JetBrains.Annotations.ImplicitUseKindFlags.Access);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Assign"))
                {
                    translator.PushJetBrainsAnnotationsImplicitUseKindFlags(L, JetBrains.Annotations.ImplicitUseKindFlags.Assign);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "InstantiatedWithFixedConstructorSignature"))
                {
                    translator.PushJetBrainsAnnotationsImplicitUseKindFlags(L, JetBrains.Annotations.ImplicitUseKindFlags.InstantiatedWithFixedConstructorSignature);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "InstantiatedNoFixedConstructorSignature"))
                {
                    translator.PushJetBrainsAnnotationsImplicitUseKindFlags(L, JetBrains.Annotations.ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for JetBrains.Annotations.ImplicitUseKindFlags!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for JetBrains.Annotations.ImplicitUseKindFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class JetBrainsAnnotationsImplicitUseTargetFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(JetBrains.Annotations.ImplicitUseTargetFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(JetBrains.Annotations.ImplicitUseTargetFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(JetBrains.Annotations.ImplicitUseTargetFlags), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Default", JetBrains.Annotations.ImplicitUseTargetFlags.Default);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Itself", JetBrains.Annotations.ImplicitUseTargetFlags.Itself);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Members", JetBrains.Annotations.ImplicitUseTargetFlags.Members);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WithMembers", JetBrains.Annotations.ImplicitUseTargetFlags.WithMembers);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(JetBrains.Annotations.ImplicitUseTargetFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushJetBrainsAnnotationsImplicitUseTargetFlags(L, (JetBrains.Annotations.ImplicitUseTargetFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Default"))
                {
                    translator.PushJetBrainsAnnotationsImplicitUseTargetFlags(L, JetBrains.Annotations.ImplicitUseTargetFlags.Default);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Itself"))
                {
                    translator.PushJetBrainsAnnotationsImplicitUseTargetFlags(L, JetBrains.Annotations.ImplicitUseTargetFlags.Itself);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Members"))
                {
                    translator.PushJetBrainsAnnotationsImplicitUseTargetFlags(L, JetBrains.Annotations.ImplicitUseTargetFlags.Members);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "WithMembers"))
                {
                    translator.PushJetBrainsAnnotationsImplicitUseTargetFlags(L, JetBrains.Annotations.ImplicitUseTargetFlags.WithMembers);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for JetBrains.Annotations.ImplicitUseTargetFlags!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for JetBrains.Annotations.ImplicitUseTargetFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class JetBrainsAnnotationsCollectionAccessTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(JetBrains.Annotations.CollectionAccessType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(JetBrains.Annotations.CollectionAccessType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(JetBrains.Annotations.CollectionAccessType), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", JetBrains.Annotations.CollectionAccessType.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Read", JetBrains.Annotations.CollectionAccessType.Read);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ModifyExistingContent", JetBrains.Annotations.CollectionAccessType.ModifyExistingContent);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UpdatedContent", JetBrains.Annotations.CollectionAccessType.UpdatedContent);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(JetBrains.Annotations.CollectionAccessType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushJetBrainsAnnotationsCollectionAccessType(L, (JetBrains.Annotations.CollectionAccessType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushJetBrainsAnnotationsCollectionAccessType(L, JetBrains.Annotations.CollectionAccessType.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Read"))
                {
                    translator.PushJetBrainsAnnotationsCollectionAccessType(L, JetBrains.Annotations.CollectionAccessType.Read);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ModifyExistingContent"))
                {
                    translator.PushJetBrainsAnnotationsCollectionAccessType(L, JetBrains.Annotations.CollectionAccessType.ModifyExistingContent);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UpdatedContent"))
                {
                    translator.PushJetBrainsAnnotationsCollectionAccessType(L, JetBrains.Annotations.CollectionAccessType.UpdatedContent);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for JetBrains.Annotations.CollectionAccessType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for JetBrains.Annotations.CollectionAccessType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class JetBrainsAnnotationsAssertionConditionTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(JetBrains.Annotations.AssertionConditionType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(JetBrains.Annotations.AssertionConditionType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(JetBrains.Annotations.AssertionConditionType), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IS_TRUE", JetBrains.Annotations.AssertionConditionType.IS_TRUE);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IS_FALSE", JetBrains.Annotations.AssertionConditionType.IS_FALSE);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IS_NULL", JetBrains.Annotations.AssertionConditionType.IS_NULL);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IS_NOT_NULL", JetBrains.Annotations.AssertionConditionType.IS_NOT_NULL);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(JetBrains.Annotations.AssertionConditionType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushJetBrainsAnnotationsAssertionConditionType(L, (JetBrains.Annotations.AssertionConditionType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "IS_TRUE"))
                {
                    translator.PushJetBrainsAnnotationsAssertionConditionType(L, JetBrains.Annotations.AssertionConditionType.IS_TRUE);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "IS_FALSE"))
                {
                    translator.PushJetBrainsAnnotationsAssertionConditionType(L, JetBrains.Annotations.AssertionConditionType.IS_FALSE);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "IS_NULL"))
                {
                    translator.PushJetBrainsAnnotationsAssertionConditionType(L, JetBrains.Annotations.AssertionConditionType.IS_NULL);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "IS_NOT_NULL"))
                {
                    translator.PushJetBrainsAnnotationsAssertionConditionType(L, JetBrains.Annotations.AssertionConditionType.IS_NOT_NULL);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for JetBrains.Annotations.AssertionConditionType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for JetBrains.Annotations.AssertionConditionType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineSendMessageOptionsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.SendMessageOptions), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.SendMessageOptions), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.SendMessageOptions), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RequireReceiver", UnityEngine.SendMessageOptions.RequireReceiver);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DontRequireReceiver", UnityEngine.SendMessageOptions.DontRequireReceiver);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.SendMessageOptions), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineSendMessageOptions(L, (UnityEngine.SendMessageOptions)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "RequireReceiver"))
                {
                    translator.PushUnityEngineSendMessageOptions(L, UnityEngine.SendMessageOptions.RequireReceiver);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DontRequireReceiver"))
                {
                    translator.PushUnityEngineSendMessageOptions(L, UnityEngine.SendMessageOptions.DontRequireReceiver);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.SendMessageOptions!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.SendMessageOptions! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEnginePrimitiveTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.PrimitiveType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.PrimitiveType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.PrimitiveType), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Sphere", UnityEngine.PrimitiveType.Sphere);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Capsule", UnityEngine.PrimitiveType.Capsule);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Cylinder", UnityEngine.PrimitiveType.Cylinder);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Cube", UnityEngine.PrimitiveType.Cube);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Plane", UnityEngine.PrimitiveType.Plane);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Quad", UnityEngine.PrimitiveType.Quad);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.PrimitiveType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEnginePrimitiveType(L, (UnityEngine.PrimitiveType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Sphere"))
                {
                    translator.PushUnityEnginePrimitiveType(L, UnityEngine.PrimitiveType.Sphere);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Capsule"))
                {
                    translator.PushUnityEnginePrimitiveType(L, UnityEngine.PrimitiveType.Capsule);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Cylinder"))
                {
                    translator.PushUnityEnginePrimitiveType(L, UnityEngine.PrimitiveType.Cylinder);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Cube"))
                {
                    translator.PushUnityEnginePrimitiveType(L, UnityEngine.PrimitiveType.Cube);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Plane"))
                {
                    translator.PushUnityEnginePrimitiveType(L, UnityEngine.PrimitiveType.Plane);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Quad"))
                {
                    translator.PushUnityEnginePrimitiveType(L, UnityEngine.PrimitiveType.Quad);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.PrimitiveType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.PrimitiveType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineSpaceWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Space), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Space), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Space), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "World", UnityEngine.Space.World);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Self", UnityEngine.Space.Self);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Space), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineSpace(L, (UnityEngine.Space)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "World"))
                {
                    translator.PushUnityEngineSpace(L, UnityEngine.Space.World);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Self"))
                {
                    translator.PushUnityEngineSpace(L, UnityEngine.Space.Self);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Space!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Space! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRuntimePlatformWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.RuntimePlatform), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.RuntimePlatform), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.RuntimePlatform), L, null, 42, 0, 0);

            Utils.RegisterEnumType(L, typeof(UnityEngine.RuntimePlatform));

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.RuntimePlatform), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRuntimePlatform(L, (UnityEngine.RuntimePlatform)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

                try
				{
                    translator.TranslateToEnumToTop(L, typeof(UnityEngine.RuntimePlatform), 1);
				}
				catch (System.Exception e)
				{
					return LuaAPI.luaL_error(L, "cast to " + typeof(UnityEngine.RuntimePlatform) + " exception:" + e);
				}

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RuntimePlatform! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineSystemLanguageWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.SystemLanguage), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.SystemLanguage), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.SystemLanguage), L, null, 45, 0, 0);

            Utils.RegisterEnumType(L, typeof(UnityEngine.SystemLanguage));

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.SystemLanguage), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineSystemLanguage(L, (UnityEngine.SystemLanguage)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

                try
				{
                    translator.TranslateToEnumToTop(L, typeof(UnityEngine.SystemLanguage), 1);
				}
				catch (System.Exception e)
				{
					return LuaAPI.luaL_error(L, "cast to " + typeof(UnityEngine.SystemLanguage) + " exception:" + e);
				}

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.SystemLanguage! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineLogTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.LogType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.LogType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.LogType), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Error", UnityEngine.LogType.Error);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Assert", UnityEngine.LogType.Assert);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Warning", UnityEngine.LogType.Warning);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Log", UnityEngine.LogType.Log);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Exception", UnityEngine.LogType.Exception);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.LogType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineLogType(L, (UnityEngine.LogType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Error"))
                {
                    translator.PushUnityEngineLogType(L, UnityEngine.LogType.Error);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Assert"))
                {
                    translator.PushUnityEngineLogType(L, UnityEngine.LogType.Assert);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Warning"))
                {
                    translator.PushUnityEngineLogType(L, UnityEngine.LogType.Warning);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Log"))
                {
                    translator.PushUnityEngineLogType(L, UnityEngine.LogType.Log);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Exception"))
                {
                    translator.PushUnityEngineLogType(L, UnityEngine.LogType.Exception);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.LogType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.LogType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineLogOptionWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.LogOption), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.LogOption), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.LogOption), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.LogOption.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NoStacktrace", UnityEngine.LogOption.NoStacktrace);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.LogOption), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineLogOption(L, (UnityEngine.LogOption)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineLogOption(L, UnityEngine.LogOption.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NoStacktrace"))
                {
                    translator.PushUnityEngineLogOption(L, UnityEngine.LogOption.NoStacktrace);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.LogOption!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.LogOption! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineThreadPriorityWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ThreadPriority), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ThreadPriority), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ThreadPriority), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Low", UnityEngine.ThreadPriority.Low);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BelowNormal", UnityEngine.ThreadPriority.BelowNormal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", UnityEngine.ThreadPriority.Normal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "High", UnityEngine.ThreadPriority.High);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ThreadPriority), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineThreadPriority(L, (UnityEngine.ThreadPriority)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Low"))
                {
                    translator.PushUnityEngineThreadPriority(L, UnityEngine.ThreadPriority.Low);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BelowNormal"))
                {
                    translator.PushUnityEngineThreadPriority(L, UnityEngine.ThreadPriority.BelowNormal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
                {
                    translator.PushUnityEngineThreadPriority(L, UnityEngine.ThreadPriority.Normal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "High"))
                {
                    translator.PushUnityEngineThreadPriority(L, UnityEngine.ThreadPriority.High);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ThreadPriority!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ThreadPriority! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineWeightedModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.WeightedMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.WeightedMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.WeightedMode), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.WeightedMode.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "In", UnityEngine.WeightedMode.In);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Out", UnityEngine.WeightedMode.Out);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Both", UnityEngine.WeightedMode.Both);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.WeightedMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineWeightedMode(L, (UnityEngine.WeightedMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineWeightedMode(L, UnityEngine.WeightedMode.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "In"))
                {
                    translator.PushUnityEngineWeightedMode(L, UnityEngine.WeightedMode.In);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Out"))
                {
                    translator.PushUnityEngineWeightedMode(L, UnityEngine.WeightedMode.Out);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Both"))
                {
                    translator.PushUnityEngineWeightedMode(L, UnityEngine.WeightedMode.Both);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.WeightedMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.WeightedMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineWrapModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.WrapMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.WrapMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.WrapMode), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Once", UnityEngine.WrapMode.Once);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Loop", UnityEngine.WrapMode.Loop);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PingPong", UnityEngine.WrapMode.PingPong);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Default", UnityEngine.WrapMode.Default);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ClampForever", UnityEngine.WrapMode.ClampForever);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Clamp", UnityEngine.WrapMode.Clamp);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.WrapMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineWrapMode(L, (UnityEngine.WrapMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Once"))
                {
                    translator.PushUnityEngineWrapMode(L, UnityEngine.WrapMode.Once);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Loop"))
                {
                    translator.PushUnityEngineWrapMode(L, UnityEngine.WrapMode.Loop);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PingPong"))
                {
                    translator.PushUnityEngineWrapMode(L, UnityEngine.WrapMode.PingPong);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Default"))
                {
                    translator.PushUnityEngineWrapMode(L, UnityEngine.WrapMode.Default);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ClampForever"))
                {
                    translator.PushUnityEngineWrapMode(L, UnityEngine.WrapMode.ClampForever);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Clamp"))
                {
                    translator.PushUnityEngineWrapMode(L, UnityEngine.WrapMode.Clamp);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.WrapMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.WrapMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineStackTraceLogTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.StackTraceLogType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.StackTraceLogType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.StackTraceLogType), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.StackTraceLogType.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ScriptOnly", UnityEngine.StackTraceLogType.ScriptOnly);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Full", UnityEngine.StackTraceLogType.Full);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.StackTraceLogType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineStackTraceLogType(L, (UnityEngine.StackTraceLogType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineStackTraceLogType(L, UnityEngine.StackTraceLogType.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ScriptOnly"))
                {
                    translator.PushUnityEngineStackTraceLogType(L, UnityEngine.StackTraceLogType.ScriptOnly);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Full"))
                {
                    translator.PushUnityEngineStackTraceLogType(L, UnityEngine.StackTraceLogType.Full);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.StackTraceLogType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.StackTraceLogType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineNetworkReachabilityWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.NetworkReachability), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.NetworkReachability), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.NetworkReachability), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NotReachable", UnityEngine.NetworkReachability.NotReachable);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReachableViaCarrierDataNetwork", UnityEngine.NetworkReachability.ReachableViaCarrierDataNetwork);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReachableViaLocalAreaNetwork", UnityEngine.NetworkReachability.ReachableViaLocalAreaNetwork);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.NetworkReachability), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineNetworkReachability(L, (UnityEngine.NetworkReachability)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "NotReachable"))
                {
                    translator.PushUnityEngineNetworkReachability(L, UnityEngine.NetworkReachability.NotReachable);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ReachableViaCarrierDataNetwork"))
                {
                    translator.PushUnityEngineNetworkReachability(L, UnityEngine.NetworkReachability.ReachableViaCarrierDataNetwork);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ReachableViaLocalAreaNetwork"))
                {
                    translator.PushUnityEngineNetworkReachability(L, UnityEngine.NetworkReachability.ReachableViaLocalAreaNetwork);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.NetworkReachability!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.NetworkReachability! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineUserAuthorizationWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.UserAuthorization), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.UserAuthorization), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.UserAuthorization), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WebCam", UnityEngine.UserAuthorization.WebCam);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Microphone", UnityEngine.UserAuthorization.Microphone);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.UserAuthorization), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineUserAuthorization(L, (UnityEngine.UserAuthorization)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "WebCam"))
                {
                    translator.PushUnityEngineUserAuthorization(L, UnityEngine.UserAuthorization.WebCam);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Microphone"))
                {
                    translator.PushUnityEngineUserAuthorization(L, UnityEngine.UserAuthorization.Microphone);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UserAuthorization!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UserAuthorization! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineApplicationInstallModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ApplicationInstallMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ApplicationInstallMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ApplicationInstallMode), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Unknown", UnityEngine.ApplicationInstallMode.Unknown);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Store", UnityEngine.ApplicationInstallMode.Store);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DeveloperBuild", UnityEngine.ApplicationInstallMode.DeveloperBuild);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Adhoc", UnityEngine.ApplicationInstallMode.Adhoc);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Enterprise", UnityEngine.ApplicationInstallMode.Enterprise);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Editor", UnityEngine.ApplicationInstallMode.Editor);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ApplicationInstallMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineApplicationInstallMode(L, (UnityEngine.ApplicationInstallMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Unknown"))
                {
                    translator.PushUnityEngineApplicationInstallMode(L, UnityEngine.ApplicationInstallMode.Unknown);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Store"))
                {
                    translator.PushUnityEngineApplicationInstallMode(L, UnityEngine.ApplicationInstallMode.Store);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DeveloperBuild"))
                {
                    translator.PushUnityEngineApplicationInstallMode(L, UnityEngine.ApplicationInstallMode.DeveloperBuild);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Adhoc"))
                {
                    translator.PushUnityEngineApplicationInstallMode(L, UnityEngine.ApplicationInstallMode.Adhoc);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Enterprise"))
                {
                    translator.PushUnityEngineApplicationInstallMode(L, UnityEngine.ApplicationInstallMode.Enterprise);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Editor"))
                {
                    translator.PushUnityEngineApplicationInstallMode(L, UnityEngine.ApplicationInstallMode.Editor);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ApplicationInstallMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ApplicationInstallMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineApplicationSandboxTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ApplicationSandboxType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ApplicationSandboxType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ApplicationSandboxType), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Unknown", UnityEngine.ApplicationSandboxType.Unknown);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NotSandboxed", UnityEngine.ApplicationSandboxType.NotSandboxed);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Sandboxed", UnityEngine.ApplicationSandboxType.Sandboxed);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SandboxBroken", UnityEngine.ApplicationSandboxType.SandboxBroken);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ApplicationSandboxType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineApplicationSandboxType(L, (UnityEngine.ApplicationSandboxType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Unknown"))
                {
                    translator.PushUnityEngineApplicationSandboxType(L, UnityEngine.ApplicationSandboxType.Unknown);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NotSandboxed"))
                {
                    translator.PushUnityEngineApplicationSandboxType(L, UnityEngine.ApplicationSandboxType.NotSandboxed);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Sandboxed"))
                {
                    translator.PushUnityEngineApplicationSandboxType(L, UnityEngine.ApplicationSandboxType.Sandboxed);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SandboxBroken"))
                {
                    translator.PushUnityEngineApplicationSandboxType(L, UnityEngine.ApplicationSandboxType.SandboxBroken);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ApplicationSandboxType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ApplicationSandboxType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAudioTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.AudioType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.AudioType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.AudioType), L, null, 14, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UNKNOWN", UnityEngine.AudioType.UNKNOWN);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ACC", UnityEngine.AudioType.ACC);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AIFF", UnityEngine.AudioType.AIFF);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IT", UnityEngine.AudioType.IT);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MOD", UnityEngine.AudioType.MOD);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MPEG", UnityEngine.AudioType.MPEG);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OGGVORBIS", UnityEngine.AudioType.OGGVORBIS);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "S3M", UnityEngine.AudioType.S3M);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WAV", UnityEngine.AudioType.WAV);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "XM", UnityEngine.AudioType.XM);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "XMA", UnityEngine.AudioType.XMA);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VAG", UnityEngine.AudioType.VAG);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AUDIOQUEUE", UnityEngine.AudioType.AUDIOQUEUE);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.AudioType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAudioType(L, (UnityEngine.AudioType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "UNKNOWN"))
                {
                    translator.PushUnityEngineAudioType(L, UnityEngine.AudioType.UNKNOWN);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ACC"))
                {
                    translator.PushUnityEngineAudioType(L, UnityEngine.AudioType.ACC);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AIFF"))
                {
                    translator.PushUnityEngineAudioType(L, UnityEngine.AudioType.AIFF);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "IT"))
                {
                    translator.PushUnityEngineAudioType(L, UnityEngine.AudioType.IT);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MOD"))
                {
                    translator.PushUnityEngineAudioType(L, UnityEngine.AudioType.MOD);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MPEG"))
                {
                    translator.PushUnityEngineAudioType(L, UnityEngine.AudioType.MPEG);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "OGGVORBIS"))
                {
                    translator.PushUnityEngineAudioType(L, UnityEngine.AudioType.OGGVORBIS);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "S3M"))
                {
                    translator.PushUnityEngineAudioType(L, UnityEngine.AudioType.S3M);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "WAV"))
                {
                    translator.PushUnityEngineAudioType(L, UnityEngine.AudioType.WAV);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "XM"))
                {
                    translator.PushUnityEngineAudioType(L, UnityEngine.AudioType.XM);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "XMA"))
                {
                    translator.PushUnityEngineAudioType(L, UnityEngine.AudioType.XMA);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "VAG"))
                {
                    translator.PushUnityEngineAudioType(L, UnityEngine.AudioType.VAG);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AUDIOQUEUE"))
                {
                    translator.PushUnityEngineAudioType(L, UnityEngine.AudioType.AUDIOQUEUE);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.AudioType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AudioType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCameraGateFitModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Camera.GateFitMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Camera.GateFitMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Camera.GateFitMode), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vertical", UnityEngine.Camera.GateFitMode.Vertical);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Horizontal", UnityEngine.Camera.GateFitMode.Horizontal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fill", UnityEngine.Camera.GateFitMode.Fill);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Overscan", UnityEngine.Camera.GateFitMode.Overscan);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Camera.GateFitMode.None);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Camera.GateFitMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCameraGateFitMode(L, (UnityEngine.Camera.GateFitMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Vertical"))
                {
                    translator.PushUnityEngineCameraGateFitMode(L, UnityEngine.Camera.GateFitMode.Vertical);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Horizontal"))
                {
                    translator.PushUnityEngineCameraGateFitMode(L, UnityEngine.Camera.GateFitMode.Horizontal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Fill"))
                {
                    translator.PushUnityEngineCameraGateFitMode(L, UnityEngine.Camera.GateFitMode.Fill);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Overscan"))
                {
                    translator.PushUnityEngineCameraGateFitMode(L, UnityEngine.Camera.GateFitMode.Overscan);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineCameraGateFitMode(L, UnityEngine.Camera.GateFitMode.None);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Camera.GateFitMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Camera.GateFitMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCameraFieldOfViewAxisWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Camera.FieldOfViewAxis), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Camera.FieldOfViewAxis), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Camera.FieldOfViewAxis), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vertical", UnityEngine.Camera.FieldOfViewAxis.Vertical);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Horizontal", UnityEngine.Camera.FieldOfViewAxis.Horizontal);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Camera.FieldOfViewAxis), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCameraFieldOfViewAxis(L, (UnityEngine.Camera.FieldOfViewAxis)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Vertical"))
                {
                    translator.PushUnityEngineCameraFieldOfViewAxis(L, UnityEngine.Camera.FieldOfViewAxis.Vertical);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Horizontal"))
                {
                    translator.PushUnityEngineCameraFieldOfViewAxis(L, UnityEngine.Camera.FieldOfViewAxis.Horizontal);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Camera.FieldOfViewAxis!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Camera.FieldOfViewAxis! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCameraStereoscopicEyeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Camera.StereoscopicEye), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Camera.StereoscopicEye), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Camera.StereoscopicEye), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Left", UnityEngine.Camera.StereoscopicEye.Left);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Right", UnityEngine.Camera.StereoscopicEye.Right);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Camera.StereoscopicEye), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCameraStereoscopicEye(L, (UnityEngine.Camera.StereoscopicEye)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Left"))
                {
                    translator.PushUnityEngineCameraStereoscopicEye(L, UnityEngine.Camera.StereoscopicEye.Left);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Right"))
                {
                    translator.PushUnityEngineCameraStereoscopicEye(L, UnityEngine.Camera.StereoscopicEye.Right);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Camera.StereoscopicEye!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Camera.StereoscopicEye! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCameraMonoOrStereoscopicEyeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Camera.MonoOrStereoscopicEye), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Camera.MonoOrStereoscopicEye), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Camera.MonoOrStereoscopicEye), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Left", UnityEngine.Camera.MonoOrStereoscopicEye.Left);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Right", UnityEngine.Camera.MonoOrStereoscopicEye.Right);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mono", UnityEngine.Camera.MonoOrStereoscopicEye.Mono);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Camera.MonoOrStereoscopicEye), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCameraMonoOrStereoscopicEye(L, (UnityEngine.Camera.MonoOrStereoscopicEye)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Left"))
                {
                    translator.PushUnityEngineCameraMonoOrStereoscopicEye(L, UnityEngine.Camera.MonoOrStereoscopicEye.Left);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Right"))
                {
                    translator.PushUnityEngineCameraMonoOrStereoscopicEye(L, UnityEngine.Camera.MonoOrStereoscopicEye.Right);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Mono"))
                {
                    translator.PushUnityEngineCameraMonoOrStereoscopicEye(L, UnityEngine.Camera.MonoOrStereoscopicEye.Mono);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Camera.MonoOrStereoscopicEye!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Camera.MonoOrStereoscopicEye! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCameraRenderRequestModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Camera.RenderRequestMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Camera.RenderRequestMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Camera.RenderRequestMode), L, null, 15, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Camera.RenderRequestMode.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ObjectId", UnityEngine.Camera.RenderRequestMode.ObjectId);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Depth", UnityEngine.Camera.RenderRequestMode.Depth);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VertexNormal", UnityEngine.Camera.RenderRequestMode.VertexNormal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WorldPosition", UnityEngine.Camera.RenderRequestMode.WorldPosition);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EntityId", UnityEngine.Camera.RenderRequestMode.EntityId);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BaseColor", UnityEngine.Camera.RenderRequestMode.BaseColor);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SpecularColor", UnityEngine.Camera.RenderRequestMode.SpecularColor);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Metallic", UnityEngine.Camera.RenderRequestMode.Metallic);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Emission", UnityEngine.Camera.RenderRequestMode.Emission);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", UnityEngine.Camera.RenderRequestMode.Normal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Smoothness", UnityEngine.Camera.RenderRequestMode.Smoothness);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Occlusion", UnityEngine.Camera.RenderRequestMode.Occlusion);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DiffuseColor", UnityEngine.Camera.RenderRequestMode.DiffuseColor);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Camera.RenderRequestMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCameraRenderRequestMode(L, (UnityEngine.Camera.RenderRequestMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ObjectId"))
                {
                    translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.ObjectId);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Depth"))
                {
                    translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.Depth);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "VertexNormal"))
                {
                    translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.VertexNormal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "WorldPosition"))
                {
                    translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.WorldPosition);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "EntityId"))
                {
                    translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.EntityId);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BaseColor"))
                {
                    translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.BaseColor);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SpecularColor"))
                {
                    translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.SpecularColor);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Metallic"))
                {
                    translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.Metallic);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Emission"))
                {
                    translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.Emission);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
                {
                    translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.Normal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Smoothness"))
                {
                    translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.Smoothness);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Occlusion"))
                {
                    translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.Occlusion);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DiffuseColor"))
                {
                    translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.DiffuseColor);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Camera.RenderRequestMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Camera.RenderRequestMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCameraRenderRequestOutputSpaceWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Camera.RenderRequestOutputSpace), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Camera.RenderRequestOutputSpace), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Camera.RenderRequestOutputSpace), L, null, 11, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ScreenSpace", UnityEngine.Camera.RenderRequestOutputSpace.ScreenSpace);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UV0", UnityEngine.Camera.RenderRequestOutputSpace.UV0);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UV1", UnityEngine.Camera.RenderRequestOutputSpace.UV1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UV2", UnityEngine.Camera.RenderRequestOutputSpace.UV2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UV3", UnityEngine.Camera.RenderRequestOutputSpace.UV3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UV4", UnityEngine.Camera.RenderRequestOutputSpace.UV4);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UV5", UnityEngine.Camera.RenderRequestOutputSpace.UV5);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UV6", UnityEngine.Camera.RenderRequestOutputSpace.UV6);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UV7", UnityEngine.Camera.RenderRequestOutputSpace.UV7);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UV8", UnityEngine.Camera.RenderRequestOutputSpace.UV8);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Camera.RenderRequestOutputSpace), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCameraRenderRequestOutputSpace(L, (UnityEngine.Camera.RenderRequestOutputSpace)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "ScreenSpace"))
                {
                    translator.PushUnityEngineCameraRenderRequestOutputSpace(L, UnityEngine.Camera.RenderRequestOutputSpace.ScreenSpace);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UV0"))
                {
                    translator.PushUnityEngineCameraRenderRequestOutputSpace(L, UnityEngine.Camera.RenderRequestOutputSpace.UV0);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UV1"))
                {
                    translator.PushUnityEngineCameraRenderRequestOutputSpace(L, UnityEngine.Camera.RenderRequestOutputSpace.UV1);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UV2"))
                {
                    translator.PushUnityEngineCameraRenderRequestOutputSpace(L, UnityEngine.Camera.RenderRequestOutputSpace.UV2);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UV3"))
                {
                    translator.PushUnityEngineCameraRenderRequestOutputSpace(L, UnityEngine.Camera.RenderRequestOutputSpace.UV3);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UV4"))
                {
                    translator.PushUnityEngineCameraRenderRequestOutputSpace(L, UnityEngine.Camera.RenderRequestOutputSpace.UV4);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UV5"))
                {
                    translator.PushUnityEngineCameraRenderRequestOutputSpace(L, UnityEngine.Camera.RenderRequestOutputSpace.UV5);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UV6"))
                {
                    translator.PushUnityEngineCameraRenderRequestOutputSpace(L, UnityEngine.Camera.RenderRequestOutputSpace.UV6);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UV7"))
                {
                    translator.PushUnityEngineCameraRenderRequestOutputSpace(L, UnityEngine.Camera.RenderRequestOutputSpace.UV7);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UV8"))
                {
                    translator.PushUnityEngineCameraRenderRequestOutputSpace(L, UnityEngine.Camera.RenderRequestOutputSpace.UV8);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Camera.RenderRequestOutputSpace!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Camera.RenderRequestOutputSpace! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineReflectionProbeReflectionProbeEventWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ReflectionProbe.ReflectionProbeEvent), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ReflectionProbe.ReflectionProbeEvent), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ReflectionProbe.ReflectionProbeEvent), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReflectionProbeAdded", UnityEngine.ReflectionProbe.ReflectionProbeEvent.ReflectionProbeAdded);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReflectionProbeRemoved", UnityEngine.ReflectionProbe.ReflectionProbeEvent.ReflectionProbeRemoved);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ReflectionProbe.ReflectionProbeEvent), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineReflectionProbeReflectionProbeEvent(L, (UnityEngine.ReflectionProbe.ReflectionProbeEvent)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "ReflectionProbeAdded"))
                {
                    translator.PushUnityEngineReflectionProbeReflectionProbeEvent(L, UnityEngine.ReflectionProbe.ReflectionProbeEvent.ReflectionProbeAdded);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ReflectionProbeRemoved"))
                {
                    translator.PushUnityEngineReflectionProbeReflectionProbeEvent(L, UnityEngine.ReflectionProbe.ReflectionProbeEvent.ReflectionProbeRemoved);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ReflectionProbe.ReflectionProbeEvent!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ReflectionProbe.ReflectionProbeEvent! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineFullScreenModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.FullScreenMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.FullScreenMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.FullScreenMode), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExclusiveFullScreen", UnityEngine.FullScreenMode.ExclusiveFullScreen);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FullScreenWindow", UnityEngine.FullScreenMode.FullScreenWindow);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MaximizedWindow", UnityEngine.FullScreenMode.MaximizedWindow);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Windowed", UnityEngine.FullScreenMode.Windowed);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.FullScreenMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineFullScreenMode(L, (UnityEngine.FullScreenMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "ExclusiveFullScreen"))
                {
                    translator.PushUnityEngineFullScreenMode(L, UnityEngine.FullScreenMode.ExclusiveFullScreen);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FullScreenWindow"))
                {
                    translator.PushUnityEngineFullScreenMode(L, UnityEngine.FullScreenMode.FullScreenWindow);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MaximizedWindow"))
                {
                    translator.PushUnityEngineFullScreenMode(L, UnityEngine.FullScreenMode.MaximizedWindow);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Windowed"))
                {
                    translator.PushUnityEngineFullScreenMode(L, UnityEngine.FullScreenMode.Windowed);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.FullScreenMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.FullScreenMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineComputeBufferModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ComputeBufferMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ComputeBufferMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ComputeBufferMode), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Immutable", UnityEngine.ComputeBufferMode.Immutable);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Dynamic", UnityEngine.ComputeBufferMode.Dynamic);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Circular", UnityEngine.ComputeBufferMode.Circular);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StreamOut", UnityEngine.ComputeBufferMode.StreamOut);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SubUpdates", UnityEngine.ComputeBufferMode.SubUpdates);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ComputeBufferMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineComputeBufferMode(L, (UnityEngine.ComputeBufferMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Immutable"))
                {
                    translator.PushUnityEngineComputeBufferMode(L, UnityEngine.ComputeBufferMode.Immutable);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Dynamic"))
                {
                    translator.PushUnityEngineComputeBufferMode(L, UnityEngine.ComputeBufferMode.Dynamic);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Circular"))
                {
                    translator.PushUnityEngineComputeBufferMode(L, UnityEngine.ComputeBufferMode.Circular);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "StreamOut"))
                {
                    translator.PushUnityEngineComputeBufferMode(L, UnityEngine.ComputeBufferMode.StreamOut);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SubUpdates"))
                {
                    translator.PushUnityEngineComputeBufferMode(L, UnityEngine.ComputeBufferMode.SubUpdates);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ComputeBufferMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ComputeBufferMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineD3DHDRDisplayBitDepthWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.D3DHDRDisplayBitDepth), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.D3DHDRDisplayBitDepth), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.D3DHDRDisplayBitDepth), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "D3DHDRDisplayBitDepth10", UnityEngine.D3DHDRDisplayBitDepth.D3DHDRDisplayBitDepth10);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "D3DHDRDisplayBitDepth16", UnityEngine.D3DHDRDisplayBitDepth.D3DHDRDisplayBitDepth16);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.D3DHDRDisplayBitDepth), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineD3DHDRDisplayBitDepth(L, (UnityEngine.D3DHDRDisplayBitDepth)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "D3DHDRDisplayBitDepth10"))
                {
                    translator.PushUnityEngineD3DHDRDisplayBitDepth(L, UnityEngine.D3DHDRDisplayBitDepth.D3DHDRDisplayBitDepth10);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "D3DHDRDisplayBitDepth16"))
                {
                    translator.PushUnityEngineD3DHDRDisplayBitDepth(L, UnityEngine.D3DHDRDisplayBitDepth.D3DHDRDisplayBitDepth16);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.D3DHDRDisplayBitDepth!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.D3DHDRDisplayBitDepth! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineLightmapsModeLegacyWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.LightmapsModeLegacy), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.LightmapsModeLegacy), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.LightmapsModeLegacy), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Single", UnityEngine.LightmapsModeLegacy.Single);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Dual", UnityEngine.LightmapsModeLegacy.Dual);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Directional", UnityEngine.LightmapsModeLegacy.Directional);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.LightmapsModeLegacy), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineLightmapsModeLegacy(L, (UnityEngine.LightmapsModeLegacy)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Single"))
                {
                    translator.PushUnityEngineLightmapsModeLegacy(L, UnityEngine.LightmapsModeLegacy.Single);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Dual"))
                {
                    translator.PushUnityEngineLightmapsModeLegacy(L, UnityEngine.LightmapsModeLegacy.Dual);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Directional"))
                {
                    translator.PushUnityEngineLightmapsModeLegacy(L, UnityEngine.LightmapsModeLegacy.Directional);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.LightmapsModeLegacy!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.LightmapsModeLegacy! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineGraphicsBufferTargetWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.GraphicsBuffer.Target), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.GraphicsBuffer.Target), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.GraphicsBuffer.Target), L, null, 9, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vertex", UnityEngine.GraphicsBuffer.Target.Vertex);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Index", UnityEngine.GraphicsBuffer.Target.Index);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Structured", UnityEngine.GraphicsBuffer.Target.Structured);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Raw", UnityEngine.GraphicsBuffer.Target.Raw);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Append", UnityEngine.GraphicsBuffer.Target.Append);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Counter", UnityEngine.GraphicsBuffer.Target.Counter);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IndirectArguments", UnityEngine.GraphicsBuffer.Target.IndirectArguments);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Constant", UnityEngine.GraphicsBuffer.Target.Constant);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.GraphicsBuffer.Target), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineGraphicsBufferTarget(L, (UnityEngine.GraphicsBuffer.Target)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Vertex"))
                {
                    translator.PushUnityEngineGraphicsBufferTarget(L, UnityEngine.GraphicsBuffer.Target.Vertex);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Index"))
                {
                    translator.PushUnityEngineGraphicsBufferTarget(L, UnityEngine.GraphicsBuffer.Target.Index);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Structured"))
                {
                    translator.PushUnityEngineGraphicsBufferTarget(L, UnityEngine.GraphicsBuffer.Target.Structured);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Raw"))
                {
                    translator.PushUnityEngineGraphicsBufferTarget(L, UnityEngine.GraphicsBuffer.Target.Raw);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Append"))
                {
                    translator.PushUnityEngineGraphicsBufferTarget(L, UnityEngine.GraphicsBuffer.Target.Append);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Counter"))
                {
                    translator.PushUnityEngineGraphicsBufferTarget(L, UnityEngine.GraphicsBuffer.Target.Counter);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "IndirectArguments"))
                {
                    translator.PushUnityEngineGraphicsBufferTarget(L, UnityEngine.GraphicsBuffer.Target.IndirectArguments);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Constant"))
                {
                    translator.PushUnityEngineGraphicsBufferTarget(L, UnityEngine.GraphicsBuffer.Target.Constant);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.GraphicsBuffer.Target!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.GraphicsBuffer.Target! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineLightShadowCasterModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.LightShadowCasterMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.LightShadowCasterMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.LightShadowCasterMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Default", UnityEngine.LightShadowCasterMode.Default);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NonLightmappedOnly", UnityEngine.LightShadowCasterMode.NonLightmappedOnly);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Everything", UnityEngine.LightShadowCasterMode.Everything);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.LightShadowCasterMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineLightShadowCasterMode(L, (UnityEngine.LightShadowCasterMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Default"))
                {
                    translator.PushUnityEngineLightShadowCasterMode(L, UnityEngine.LightShadowCasterMode.Default);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NonLightmappedOnly"))
                {
                    translator.PushUnityEngineLightShadowCasterMode(L, UnityEngine.LightShadowCasterMode.NonLightmappedOnly);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Everything"))
                {
                    translator.PushUnityEngineLightShadowCasterMode(L, UnityEngine.LightShadowCasterMode.Everything);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.LightShadowCasterMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.LightShadowCasterMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingPathWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.RenderingPath), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.RenderingPath), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.RenderingPath), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UsePlayerSettings", UnityEngine.RenderingPath.UsePlayerSettings);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VertexLit", UnityEngine.RenderingPath.VertexLit);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Forward", UnityEngine.RenderingPath.Forward);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DeferredLighting", UnityEngine.RenderingPath.DeferredLighting);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DeferredShading", UnityEngine.RenderingPath.DeferredShading);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.RenderingPath), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingPath(L, (UnityEngine.RenderingPath)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "UsePlayerSettings"))
                {
                    translator.PushUnityEngineRenderingPath(L, UnityEngine.RenderingPath.UsePlayerSettings);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "VertexLit"))
                {
                    translator.PushUnityEngineRenderingPath(L, UnityEngine.RenderingPath.VertexLit);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Forward"))
                {
                    translator.PushUnityEngineRenderingPath(L, UnityEngine.RenderingPath.Forward);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DeferredLighting"))
                {
                    translator.PushUnityEngineRenderingPath(L, UnityEngine.RenderingPath.DeferredLighting);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DeferredShading"))
                {
                    translator.PushUnityEngineRenderingPath(L, UnityEngine.RenderingPath.DeferredShading);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.RenderingPath!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RenderingPath! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineTransparencySortModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.TransparencySortMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.TransparencySortMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.TransparencySortMode), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Default", UnityEngine.TransparencySortMode.Default);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Perspective", UnityEngine.TransparencySortMode.Perspective);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Orthographic", UnityEngine.TransparencySortMode.Orthographic);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CustomAxis", UnityEngine.TransparencySortMode.CustomAxis);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.TransparencySortMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineTransparencySortMode(L, (UnityEngine.TransparencySortMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Default"))
                {
                    translator.PushUnityEngineTransparencySortMode(L, UnityEngine.TransparencySortMode.Default);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Perspective"))
                {
                    translator.PushUnityEngineTransparencySortMode(L, UnityEngine.TransparencySortMode.Perspective);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Orthographic"))
                {
                    translator.PushUnityEngineTransparencySortMode(L, UnityEngine.TransparencySortMode.Orthographic);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CustomAxis"))
                {
                    translator.PushUnityEngineTransparencySortMode(L, UnityEngine.TransparencySortMode.CustomAxis);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.TransparencySortMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.TransparencySortMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineStereoTargetEyeMaskWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.StereoTargetEyeMask), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.StereoTargetEyeMask), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.StereoTargetEyeMask), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.StereoTargetEyeMask.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Left", UnityEngine.StereoTargetEyeMask.Left);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Right", UnityEngine.StereoTargetEyeMask.Right);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Both", UnityEngine.StereoTargetEyeMask.Both);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.StereoTargetEyeMask), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineStereoTargetEyeMask(L, (UnityEngine.StereoTargetEyeMask)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineStereoTargetEyeMask(L, UnityEngine.StereoTargetEyeMask.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Left"))
                {
                    translator.PushUnityEngineStereoTargetEyeMask(L, UnityEngine.StereoTargetEyeMask.Left);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Right"))
                {
                    translator.PushUnityEngineStereoTargetEyeMask(L, UnityEngine.StereoTargetEyeMask.Right);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Both"))
                {
                    translator.PushUnityEngineStereoTargetEyeMask(L, UnityEngine.StereoTargetEyeMask.Both);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.StereoTargetEyeMask!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.StereoTargetEyeMask! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCameraTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.CameraType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.CameraType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.CameraType), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Game", UnityEngine.CameraType.Game);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SceneView", UnityEngine.CameraType.SceneView);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Preview", UnityEngine.CameraType.Preview);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VR", UnityEngine.CameraType.VR);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Reflection", UnityEngine.CameraType.Reflection);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.CameraType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCameraType(L, (UnityEngine.CameraType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Game"))
                {
                    translator.PushUnityEngineCameraType(L, UnityEngine.CameraType.Game);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SceneView"))
                {
                    translator.PushUnityEngineCameraType(L, UnityEngine.CameraType.SceneView);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Preview"))
                {
                    translator.PushUnityEngineCameraType(L, UnityEngine.CameraType.Preview);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "VR"))
                {
                    translator.PushUnityEngineCameraType(L, UnityEngine.CameraType.VR);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Reflection"))
                {
                    translator.PushUnityEngineCameraType(L, UnityEngine.CameraType.Reflection);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.CameraType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.CameraType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineComputeBufferTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ComputeBufferType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ComputeBufferType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ComputeBufferType), L, null, 10, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Default", UnityEngine.ComputeBufferType.Default);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Raw", UnityEngine.ComputeBufferType.Raw);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Append", UnityEngine.ComputeBufferType.Append);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Counter", UnityEngine.ComputeBufferType.Counter);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Constant", UnityEngine.ComputeBufferType.Constant);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Structured", UnityEngine.ComputeBufferType.Structured);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IndirectArguments", UnityEngine.ComputeBufferType.IndirectArguments);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ComputeBufferType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineComputeBufferType(L, (UnityEngine.ComputeBufferType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Default"))
                {
                    translator.PushUnityEngineComputeBufferType(L, UnityEngine.ComputeBufferType.Default);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Raw"))
                {
                    translator.PushUnityEngineComputeBufferType(L, UnityEngine.ComputeBufferType.Raw);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Append"))
                {
                    translator.PushUnityEngineComputeBufferType(L, UnityEngine.ComputeBufferType.Append);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Counter"))
                {
                    translator.PushUnityEngineComputeBufferType(L, UnityEngine.ComputeBufferType.Counter);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Constant"))
                {
                    translator.PushUnityEngineComputeBufferType(L, UnityEngine.ComputeBufferType.Constant);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Structured"))
                {
                    translator.PushUnityEngineComputeBufferType(L, UnityEngine.ComputeBufferType.Structured);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "IndirectArguments"))
                {
                    translator.PushUnityEngineComputeBufferType(L, UnityEngine.ComputeBufferType.IndirectArguments);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ComputeBufferType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ComputeBufferType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineLightTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.LightType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.LightType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.LightType), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Spot", UnityEngine.LightType.Spot);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Directional", UnityEngine.LightType.Directional);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Point", UnityEngine.LightType.Point);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Area", UnityEngine.LightType.Area);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Rectangle", UnityEngine.LightType.Rectangle);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Disc", UnityEngine.LightType.Disc);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.LightType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineLightType(L, (UnityEngine.LightType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Spot"))
                {
                    translator.PushUnityEngineLightType(L, UnityEngine.LightType.Spot);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Directional"))
                {
                    translator.PushUnityEngineLightType(L, UnityEngine.LightType.Directional);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Point"))
                {
                    translator.PushUnityEngineLightType(L, UnityEngine.LightType.Point);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Area"))
                {
                    translator.PushUnityEngineLightType(L, UnityEngine.LightType.Area);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Rectangle"))
                {
                    translator.PushUnityEngineLightType(L, UnityEngine.LightType.Rectangle);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Disc"))
                {
                    translator.PushUnityEngineLightType(L, UnityEngine.LightType.Disc);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.LightType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.LightType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineLightShapeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.LightShape), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.LightShape), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.LightShape), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Cone", UnityEngine.LightShape.Cone);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pyramid", UnityEngine.LightShape.Pyramid);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Box", UnityEngine.LightShape.Box);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.LightShape), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineLightShape(L, (UnityEngine.LightShape)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Cone"))
                {
                    translator.PushUnityEngineLightShape(L, UnityEngine.LightShape.Cone);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Pyramid"))
                {
                    translator.PushUnityEngineLightShape(L, UnityEngine.LightShape.Pyramid);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Box"))
                {
                    translator.PushUnityEngineLightShape(L, UnityEngine.LightShape.Box);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.LightShape!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.LightShape! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineLightRenderModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.LightRenderMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.LightRenderMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.LightRenderMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Auto", UnityEngine.LightRenderMode.Auto);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ForcePixel", UnityEngine.LightRenderMode.ForcePixel);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ForceVertex", UnityEngine.LightRenderMode.ForceVertex);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.LightRenderMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineLightRenderMode(L, (UnityEngine.LightRenderMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Auto"))
                {
                    translator.PushUnityEngineLightRenderMode(L, UnityEngine.LightRenderMode.Auto);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ForcePixel"))
                {
                    translator.PushUnityEngineLightRenderMode(L, UnityEngine.LightRenderMode.ForcePixel);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ForceVertex"))
                {
                    translator.PushUnityEngineLightRenderMode(L, UnityEngine.LightRenderMode.ForceVertex);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.LightRenderMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.LightRenderMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineLightShadowsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.LightShadows), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.LightShadows), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.LightShadows), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.LightShadows.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Hard", UnityEngine.LightShadows.Hard);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Soft", UnityEngine.LightShadows.Soft);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.LightShadows), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineLightShadows(L, (UnityEngine.LightShadows)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineLightShadows(L, UnityEngine.LightShadows.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Hard"))
                {
                    translator.PushUnityEngineLightShadows(L, UnityEngine.LightShadows.Hard);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Soft"))
                {
                    translator.PushUnityEngineLightShadows(L, UnityEngine.LightShadows.Soft);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.LightShadows!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.LightShadows! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineFogModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.FogMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.FogMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.FogMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Linear", UnityEngine.FogMode.Linear);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Exponential", UnityEngine.FogMode.Exponential);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExponentialSquared", UnityEngine.FogMode.ExponentialSquared);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.FogMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineFogMode(L, (UnityEngine.FogMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Linear"))
                {
                    translator.PushUnityEngineFogMode(L, UnityEngine.FogMode.Linear);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Exponential"))
                {
                    translator.PushUnityEngineFogMode(L, UnityEngine.FogMode.Exponential);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ExponentialSquared"))
                {
                    translator.PushUnityEngineFogMode(L, UnityEngine.FogMode.ExponentialSquared);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.FogMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.FogMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineLightmapBakeTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.LightmapBakeType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.LightmapBakeType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.LightmapBakeType), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Realtime", UnityEngine.LightmapBakeType.Realtime);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Baked", UnityEngine.LightmapBakeType.Baked);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mixed", UnityEngine.LightmapBakeType.Mixed);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.LightmapBakeType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineLightmapBakeType(L, (UnityEngine.LightmapBakeType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Realtime"))
                {
                    translator.PushUnityEngineLightmapBakeType(L, UnityEngine.LightmapBakeType.Realtime);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Baked"))
                {
                    translator.PushUnityEngineLightmapBakeType(L, UnityEngine.LightmapBakeType.Baked);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Mixed"))
                {
                    translator.PushUnityEngineLightmapBakeType(L, UnityEngine.LightmapBakeType.Mixed);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.LightmapBakeType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.LightmapBakeType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineMixedLightingModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.MixedLightingMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.MixedLightingMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.MixedLightingMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IndirectOnly", UnityEngine.MixedLightingMode.IndirectOnly);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Shadowmask", UnityEngine.MixedLightingMode.Shadowmask);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Subtractive", UnityEngine.MixedLightingMode.Subtractive);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.MixedLightingMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineMixedLightingMode(L, (UnityEngine.MixedLightingMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "IndirectOnly"))
                {
                    translator.PushUnityEngineMixedLightingMode(L, UnityEngine.MixedLightingMode.IndirectOnly);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Shadowmask"))
                {
                    translator.PushUnityEngineMixedLightingMode(L, UnityEngine.MixedLightingMode.Shadowmask);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Subtractive"))
                {
                    translator.PushUnityEngineMixedLightingMode(L, UnityEngine.MixedLightingMode.Subtractive);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.MixedLightingMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.MixedLightingMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineReceiveGIWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ReceiveGI), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ReceiveGI), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ReceiveGI), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Lightmaps", UnityEngine.ReceiveGI.Lightmaps);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LightProbes", UnityEngine.ReceiveGI.LightProbes);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ReceiveGI), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineReceiveGI(L, (UnityEngine.ReceiveGI)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Lightmaps"))
                {
                    translator.PushUnityEngineReceiveGI(L, UnityEngine.ReceiveGI.Lightmaps);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LightProbes"))
                {
                    translator.PushUnityEngineReceiveGI(L, UnityEngine.ReceiveGI.LightProbes);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ReceiveGI!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ReceiveGI! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineShadowProjectionWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ShadowProjection), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ShadowProjection), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ShadowProjection), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CloseFit", UnityEngine.ShadowProjection.CloseFit);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StableFit", UnityEngine.ShadowProjection.StableFit);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ShadowProjection), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineShadowProjection(L, (UnityEngine.ShadowProjection)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "CloseFit"))
                {
                    translator.PushUnityEngineShadowProjection(L, UnityEngine.ShadowProjection.CloseFit);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "StableFit"))
                {
                    translator.PushUnityEngineShadowProjection(L, UnityEngine.ShadowProjection.StableFit);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ShadowProjection!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ShadowProjection! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineShadowQualityWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ShadowQuality), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ShadowQuality), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ShadowQuality), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Disable", UnityEngine.ShadowQuality.Disable);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HardOnly", UnityEngine.ShadowQuality.HardOnly);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "All", UnityEngine.ShadowQuality.All);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ShadowQuality), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineShadowQuality(L, (UnityEngine.ShadowQuality)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Disable"))
                {
                    translator.PushUnityEngineShadowQuality(L, UnityEngine.ShadowQuality.Disable);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "HardOnly"))
                {
                    translator.PushUnityEngineShadowQuality(L, UnityEngine.ShadowQuality.HardOnly);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "All"))
                {
                    translator.PushUnityEngineShadowQuality(L, UnityEngine.ShadowQuality.All);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ShadowQuality!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ShadowQuality! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineShadowResolutionWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ShadowResolution), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ShadowResolution), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ShadowResolution), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Low", UnityEngine.ShadowResolution.Low);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Medium", UnityEngine.ShadowResolution.Medium);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "High", UnityEngine.ShadowResolution.High);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VeryHigh", UnityEngine.ShadowResolution.VeryHigh);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ShadowResolution), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineShadowResolution(L, (UnityEngine.ShadowResolution)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Low"))
                {
                    translator.PushUnityEngineShadowResolution(L, UnityEngine.ShadowResolution.Low);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Medium"))
                {
                    translator.PushUnityEngineShadowResolution(L, UnityEngine.ShadowResolution.Medium);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "High"))
                {
                    translator.PushUnityEngineShadowResolution(L, UnityEngine.ShadowResolution.High);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "VeryHigh"))
                {
                    translator.PushUnityEngineShadowResolution(L, UnityEngine.ShadowResolution.VeryHigh);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ShadowResolution!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ShadowResolution! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineShadowmaskModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ShadowmaskMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ShadowmaskMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ShadowmaskMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Shadowmask", UnityEngine.ShadowmaskMode.Shadowmask);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DistanceShadowmask", UnityEngine.ShadowmaskMode.DistanceShadowmask);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ShadowmaskMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineShadowmaskMode(L, (UnityEngine.ShadowmaskMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Shadowmask"))
                {
                    translator.PushUnityEngineShadowmaskMode(L, UnityEngine.ShadowmaskMode.Shadowmask);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DistanceShadowmask"))
                {
                    translator.PushUnityEngineShadowmaskMode(L, UnityEngine.ShadowmaskMode.DistanceShadowmask);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ShadowmaskMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ShadowmaskMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCameraClearFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.CameraClearFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.CameraClearFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.CameraClearFlags), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Skybox", UnityEngine.CameraClearFlags.Skybox);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Color", UnityEngine.CameraClearFlags.Color);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SolidColor", UnityEngine.CameraClearFlags.SolidColor);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Depth", UnityEngine.CameraClearFlags.Depth);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Nothing", UnityEngine.CameraClearFlags.Nothing);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.CameraClearFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCameraClearFlags(L, (UnityEngine.CameraClearFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Skybox"))
                {
                    translator.PushUnityEngineCameraClearFlags(L, UnityEngine.CameraClearFlags.Skybox);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Color"))
                {
                    translator.PushUnityEngineCameraClearFlags(L, UnityEngine.CameraClearFlags.Color);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SolidColor"))
                {
                    translator.PushUnityEngineCameraClearFlags(L, UnityEngine.CameraClearFlags.SolidColor);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Depth"))
                {
                    translator.PushUnityEngineCameraClearFlags(L, UnityEngine.CameraClearFlags.Depth);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Nothing"))
                {
                    translator.PushUnityEngineCameraClearFlags(L, UnityEngine.CameraClearFlags.Nothing);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.CameraClearFlags!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.CameraClearFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineDepthTextureModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.DepthTextureMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.DepthTextureMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.DepthTextureMode), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.DepthTextureMode.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Depth", UnityEngine.DepthTextureMode.Depth);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DepthNormals", UnityEngine.DepthTextureMode.DepthNormals);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MotionVectors", UnityEngine.DepthTextureMode.MotionVectors);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.DepthTextureMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineDepthTextureMode(L, (UnityEngine.DepthTextureMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineDepthTextureMode(L, UnityEngine.DepthTextureMode.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Depth"))
                {
                    translator.PushUnityEngineDepthTextureMode(L, UnityEngine.DepthTextureMode.Depth);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DepthNormals"))
                {
                    translator.PushUnityEngineDepthTextureMode(L, UnityEngine.DepthTextureMode.DepthNormals);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MotionVectors"))
                {
                    translator.PushUnityEngineDepthTextureMode(L, UnityEngine.DepthTextureMode.MotionVectors);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.DepthTextureMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.DepthTextureMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineTexGenModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.TexGenMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.TexGenMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.TexGenMode), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.TexGenMode.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SphereMap", UnityEngine.TexGenMode.SphereMap);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Object", UnityEngine.TexGenMode.Object);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EyeLinear", UnityEngine.TexGenMode.EyeLinear);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CubeReflect", UnityEngine.TexGenMode.CubeReflect);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CubeNormal", UnityEngine.TexGenMode.CubeNormal);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.TexGenMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineTexGenMode(L, (UnityEngine.TexGenMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineTexGenMode(L, UnityEngine.TexGenMode.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SphereMap"))
                {
                    translator.PushUnityEngineTexGenMode(L, UnityEngine.TexGenMode.SphereMap);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Object"))
                {
                    translator.PushUnityEngineTexGenMode(L, UnityEngine.TexGenMode.Object);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "EyeLinear"))
                {
                    translator.PushUnityEngineTexGenMode(L, UnityEngine.TexGenMode.EyeLinear);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CubeReflect"))
                {
                    translator.PushUnityEngineTexGenMode(L, UnityEngine.TexGenMode.CubeReflect);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CubeNormal"))
                {
                    translator.PushUnityEngineTexGenMode(L, UnityEngine.TexGenMode.CubeNormal);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.TexGenMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.TexGenMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAnisotropicFilteringWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.AnisotropicFiltering), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.AnisotropicFiltering), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.AnisotropicFiltering), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Disable", UnityEngine.AnisotropicFiltering.Disable);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Enable", UnityEngine.AnisotropicFiltering.Enable);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ForceEnable", UnityEngine.AnisotropicFiltering.ForceEnable);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.AnisotropicFiltering), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAnisotropicFiltering(L, (UnityEngine.AnisotropicFiltering)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Disable"))
                {
                    translator.PushUnityEngineAnisotropicFiltering(L, UnityEngine.AnisotropicFiltering.Disable);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Enable"))
                {
                    translator.PushUnityEngineAnisotropicFiltering(L, UnityEngine.AnisotropicFiltering.Enable);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ForceEnable"))
                {
                    translator.PushUnityEngineAnisotropicFiltering(L, UnityEngine.AnisotropicFiltering.ForceEnable);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.AnisotropicFiltering!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AnisotropicFiltering! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineSkinWeightsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.SkinWeights), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.SkinWeights), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.SkinWeights), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OneBone", UnityEngine.SkinWeights.OneBone);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TwoBones", UnityEngine.SkinWeights.TwoBones);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FourBones", UnityEngine.SkinWeights.FourBones);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Unlimited", UnityEngine.SkinWeights.Unlimited);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.SkinWeights), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineSkinWeights(L, (UnityEngine.SkinWeights)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "OneBone"))
                {
                    translator.PushUnityEngineSkinWeights(L, UnityEngine.SkinWeights.OneBone);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TwoBones"))
                {
                    translator.PushUnityEngineSkinWeights(L, UnityEngine.SkinWeights.TwoBones);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FourBones"))
                {
                    translator.PushUnityEngineSkinWeights(L, UnityEngine.SkinWeights.FourBones);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Unlimited"))
                {
                    translator.PushUnityEngineSkinWeights(L, UnityEngine.SkinWeights.Unlimited);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.SkinWeights!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.SkinWeights! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineMeshTopologyWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.MeshTopology), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.MeshTopology), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.MeshTopology), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Triangles", UnityEngine.MeshTopology.Triangles);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Quads", UnityEngine.MeshTopology.Quads);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Lines", UnityEngine.MeshTopology.Lines);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LineStrip", UnityEngine.MeshTopology.LineStrip);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Points", UnityEngine.MeshTopology.Points);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.MeshTopology), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineMeshTopology(L, (UnityEngine.MeshTopology)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Triangles"))
                {
                    translator.PushUnityEngineMeshTopology(L, UnityEngine.MeshTopology.Triangles);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Quads"))
                {
                    translator.PushUnityEngineMeshTopology(L, UnityEngine.MeshTopology.Quads);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Lines"))
                {
                    translator.PushUnityEngineMeshTopology(L, UnityEngine.MeshTopology.Lines);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LineStrip"))
                {
                    translator.PushUnityEngineMeshTopology(L, UnityEngine.MeshTopology.LineStrip);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Points"))
                {
                    translator.PushUnityEngineMeshTopology(L, UnityEngine.MeshTopology.Points);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.MeshTopology!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.MeshTopology! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineSkinQualityWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.SkinQuality), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.SkinQuality), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.SkinQuality), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Auto", UnityEngine.SkinQuality.Auto);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Bone1", UnityEngine.SkinQuality.Bone1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Bone2", UnityEngine.SkinQuality.Bone2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Bone4", UnityEngine.SkinQuality.Bone4);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.SkinQuality), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineSkinQuality(L, (UnityEngine.SkinQuality)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Auto"))
                {
                    translator.PushUnityEngineSkinQuality(L, UnityEngine.SkinQuality.Auto);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Bone1"))
                {
                    translator.PushUnityEngineSkinQuality(L, UnityEngine.SkinQuality.Bone1);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Bone2"))
                {
                    translator.PushUnityEngineSkinQuality(L, UnityEngine.SkinQuality.Bone2);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Bone4"))
                {
                    translator.PushUnityEngineSkinQuality(L, UnityEngine.SkinQuality.Bone4);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.SkinQuality!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.SkinQuality! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineColorSpaceWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ColorSpace), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ColorSpace), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ColorSpace), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Uninitialized", UnityEngine.ColorSpace.Uninitialized);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Gamma", UnityEngine.ColorSpace.Gamma);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Linear", UnityEngine.ColorSpace.Linear);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ColorSpace), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineColorSpace(L, (UnityEngine.ColorSpace)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Uninitialized"))
                {
                    translator.PushUnityEngineColorSpace(L, UnityEngine.ColorSpace.Uninitialized);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Gamma"))
                {
                    translator.PushUnityEngineColorSpace(L, UnityEngine.ColorSpace.Gamma);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Linear"))
                {
                    translator.PushUnityEngineColorSpace(L, UnityEngine.ColorSpace.Linear);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ColorSpace!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ColorSpace! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineColorGamutWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ColorGamut), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ColorGamut), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ColorGamut), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "sRGB", UnityEngine.ColorGamut.sRGB);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Rec709", UnityEngine.ColorGamut.Rec709);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Rec2020", UnityEngine.ColorGamut.Rec2020);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DisplayP3", UnityEngine.ColorGamut.DisplayP3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HDR10", UnityEngine.ColorGamut.HDR10);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DolbyHDR", UnityEngine.ColorGamut.DolbyHDR);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ColorGamut), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineColorGamut(L, (UnityEngine.ColorGamut)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "sRGB"))
                {
                    translator.PushUnityEngineColorGamut(L, UnityEngine.ColorGamut.sRGB);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Rec709"))
                {
                    translator.PushUnityEngineColorGamut(L, UnityEngine.ColorGamut.Rec709);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Rec2020"))
                {
                    translator.PushUnityEngineColorGamut(L, UnityEngine.ColorGamut.Rec2020);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DisplayP3"))
                {
                    translator.PushUnityEngineColorGamut(L, UnityEngine.ColorGamut.DisplayP3);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "HDR10"))
                {
                    translator.PushUnityEngineColorGamut(L, UnityEngine.ColorGamut.HDR10);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DolbyHDR"))
                {
                    translator.PushUnityEngineColorGamut(L, UnityEngine.ColorGamut.DolbyHDR);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ColorGamut!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ColorGamut! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineScreenOrientationWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ScreenOrientation), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ScreenOrientation), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ScreenOrientation), L, null, 8, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Portrait", UnityEngine.ScreenOrientation.Portrait);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PortraitUpsideDown", UnityEngine.ScreenOrientation.PortraitUpsideDown);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LandscapeLeft", UnityEngine.ScreenOrientation.LandscapeLeft);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LandscapeRight", UnityEngine.ScreenOrientation.LandscapeRight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AutoRotation", UnityEngine.ScreenOrientation.AutoRotation);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Landscape", UnityEngine.ScreenOrientation.Landscape);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ScreenOrientation), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineScreenOrientation(L, (UnityEngine.ScreenOrientation)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Portrait"))
                {
                    translator.PushUnityEngineScreenOrientation(L, UnityEngine.ScreenOrientation.Portrait);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PortraitUpsideDown"))
                {
                    translator.PushUnityEngineScreenOrientation(L, UnityEngine.ScreenOrientation.PortraitUpsideDown);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LandscapeLeft"))
                {
                    translator.PushUnityEngineScreenOrientation(L, UnityEngine.ScreenOrientation.LandscapeLeft);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LandscapeRight"))
                {
                    translator.PushUnityEngineScreenOrientation(L, UnityEngine.ScreenOrientation.LandscapeRight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AutoRotation"))
                {
                    translator.PushUnityEngineScreenOrientation(L, UnityEngine.ScreenOrientation.AutoRotation);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Landscape"))
                {
                    translator.PushUnityEngineScreenOrientation(L, UnityEngine.ScreenOrientation.Landscape);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ScreenOrientation!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ScreenOrientation! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineFilterModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.FilterMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.FilterMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.FilterMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Point", UnityEngine.FilterMode.Point);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Bilinear", UnityEngine.FilterMode.Bilinear);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Trilinear", UnityEngine.FilterMode.Trilinear);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.FilterMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineFilterMode(L, (UnityEngine.FilterMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Point"))
                {
                    translator.PushUnityEngineFilterMode(L, UnityEngine.FilterMode.Point);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Bilinear"))
                {
                    translator.PushUnityEngineFilterMode(L, UnityEngine.FilterMode.Bilinear);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Trilinear"))
                {
                    translator.PushUnityEngineFilterMode(L, UnityEngine.FilterMode.Trilinear);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.FilterMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.FilterMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineTextureWrapModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.TextureWrapMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.TextureWrapMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.TextureWrapMode), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Repeat", UnityEngine.TextureWrapMode.Repeat);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Clamp", UnityEngine.TextureWrapMode.Clamp);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mirror", UnityEngine.TextureWrapMode.Mirror);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MirrorOnce", UnityEngine.TextureWrapMode.MirrorOnce);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.TextureWrapMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineTextureWrapMode(L, (UnityEngine.TextureWrapMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Repeat"))
                {
                    translator.PushUnityEngineTextureWrapMode(L, UnityEngine.TextureWrapMode.Repeat);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Clamp"))
                {
                    translator.PushUnityEngineTextureWrapMode(L, UnityEngine.TextureWrapMode.Clamp);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Mirror"))
                {
                    translator.PushUnityEngineTextureWrapMode(L, UnityEngine.TextureWrapMode.Mirror);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MirrorOnce"))
                {
                    translator.PushUnityEngineTextureWrapMode(L, UnityEngine.TextureWrapMode.MirrorOnce);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.TextureWrapMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.TextureWrapMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineNPOTSupportWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.NPOTSupport), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.NPOTSupport), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.NPOTSupport), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Restricted", UnityEngine.NPOTSupport.Restricted);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Full", UnityEngine.NPOTSupport.Full);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.NPOTSupport), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineNPOTSupport(L, (UnityEngine.NPOTSupport)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Restricted"))
                {
                    translator.PushUnityEngineNPOTSupport(L, UnityEngine.NPOTSupport.Restricted);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Full"))
                {
                    translator.PushUnityEngineNPOTSupport(L, UnityEngine.NPOTSupport.Full);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.NPOTSupport!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.NPOTSupport! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineTextureFormatWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.TextureFormat), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.TextureFormat), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.TextureFormat), L, null, 77, 0, 0);

            Utils.RegisterEnumType(L, typeof(UnityEngine.TextureFormat));

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.TextureFormat), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineTextureFormat(L, (UnityEngine.TextureFormat)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

                try
				{
                    translator.TranslateToEnumToTop(L, typeof(UnityEngine.TextureFormat), 1);
				}
				catch (System.Exception e)
				{
					return LuaAPI.luaL_error(L, "cast to " + typeof(UnityEngine.TextureFormat) + " exception:" + e);
				}

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.TextureFormat! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCubemapFaceWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.CubemapFace), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.CubemapFace), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.CubemapFace), L, null, 8, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Unknown", UnityEngine.CubemapFace.Unknown);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PositiveX", UnityEngine.CubemapFace.PositiveX);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NegativeX", UnityEngine.CubemapFace.NegativeX);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PositiveY", UnityEngine.CubemapFace.PositiveY);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NegativeY", UnityEngine.CubemapFace.NegativeY);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PositiveZ", UnityEngine.CubemapFace.PositiveZ);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NegativeZ", UnityEngine.CubemapFace.NegativeZ);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.CubemapFace), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCubemapFace(L, (UnityEngine.CubemapFace)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Unknown"))
                {
                    translator.PushUnityEngineCubemapFace(L, UnityEngine.CubemapFace.Unknown);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PositiveX"))
                {
                    translator.PushUnityEngineCubemapFace(L, UnityEngine.CubemapFace.PositiveX);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NegativeX"))
                {
                    translator.PushUnityEngineCubemapFace(L, UnityEngine.CubemapFace.NegativeX);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PositiveY"))
                {
                    translator.PushUnityEngineCubemapFace(L, UnityEngine.CubemapFace.PositiveY);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NegativeY"))
                {
                    translator.PushUnityEngineCubemapFace(L, UnityEngine.CubemapFace.NegativeY);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PositiveZ"))
                {
                    translator.PushUnityEngineCubemapFace(L, UnityEngine.CubemapFace.PositiveZ);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NegativeZ"))
                {
                    translator.PushUnityEngineCubemapFace(L, UnityEngine.CubemapFace.NegativeZ);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.CubemapFace!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.CubemapFace! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderTextureFormatWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.RenderTextureFormat), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.RenderTextureFormat), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.RenderTextureFormat), L, null, 29, 0, 0);

            Utils.RegisterEnumType(L, typeof(UnityEngine.RenderTextureFormat));

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.RenderTextureFormat), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderTextureFormat(L, (UnityEngine.RenderTextureFormat)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

                try
				{
                    translator.TranslateToEnumToTop(L, typeof(UnityEngine.RenderTextureFormat), 1);
				}
				catch (System.Exception e)
				{
					return LuaAPI.luaL_error(L, "cast to " + typeof(UnityEngine.RenderTextureFormat) + " exception:" + e);
				}

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RenderTextureFormat! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineVRTextureUsageWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.VRTextureUsage), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.VRTextureUsage), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.VRTextureUsage), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.VRTextureUsage.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OneEye", UnityEngine.VRTextureUsage.OneEye);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TwoEyes", UnityEngine.VRTextureUsage.TwoEyes);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DeviceSpecific", UnityEngine.VRTextureUsage.DeviceSpecific);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.VRTextureUsage), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineVRTextureUsage(L, (UnityEngine.VRTextureUsage)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineVRTextureUsage(L, UnityEngine.VRTextureUsage.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "OneEye"))
                {
                    translator.PushUnityEngineVRTextureUsage(L, UnityEngine.VRTextureUsage.OneEye);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TwoEyes"))
                {
                    translator.PushUnityEngineVRTextureUsage(L, UnityEngine.VRTextureUsage.TwoEyes);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DeviceSpecific"))
                {
                    translator.PushUnityEngineVRTextureUsage(L, UnityEngine.VRTextureUsage.DeviceSpecific);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.VRTextureUsage!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.VRTextureUsage! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderTextureCreationFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.RenderTextureCreationFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.RenderTextureCreationFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.RenderTextureCreationFlags), L, null, 11, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MipMap", UnityEngine.RenderTextureCreationFlags.MipMap);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AutoGenerateMips", UnityEngine.RenderTextureCreationFlags.AutoGenerateMips);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SRGB", UnityEngine.RenderTextureCreationFlags.SRGB);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EyeTexture", UnityEngine.RenderTextureCreationFlags.EyeTexture);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EnableRandomWrite", UnityEngine.RenderTextureCreationFlags.EnableRandomWrite);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CreatedFromScript", UnityEngine.RenderTextureCreationFlags.CreatedFromScript);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AllowVerticalFlip", UnityEngine.RenderTextureCreationFlags.AllowVerticalFlip);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NoResolvedColorSurface", UnityEngine.RenderTextureCreationFlags.NoResolvedColorSurface);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DynamicallyScalable", UnityEngine.RenderTextureCreationFlags.DynamicallyScalable);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BindMS", UnityEngine.RenderTextureCreationFlags.BindMS);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.RenderTextureCreationFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderTextureCreationFlags(L, (UnityEngine.RenderTextureCreationFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "MipMap"))
                {
                    translator.PushUnityEngineRenderTextureCreationFlags(L, UnityEngine.RenderTextureCreationFlags.MipMap);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AutoGenerateMips"))
                {
                    translator.PushUnityEngineRenderTextureCreationFlags(L, UnityEngine.RenderTextureCreationFlags.AutoGenerateMips);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SRGB"))
                {
                    translator.PushUnityEngineRenderTextureCreationFlags(L, UnityEngine.RenderTextureCreationFlags.SRGB);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "EyeTexture"))
                {
                    translator.PushUnityEngineRenderTextureCreationFlags(L, UnityEngine.RenderTextureCreationFlags.EyeTexture);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "EnableRandomWrite"))
                {
                    translator.PushUnityEngineRenderTextureCreationFlags(L, UnityEngine.RenderTextureCreationFlags.EnableRandomWrite);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CreatedFromScript"))
                {
                    translator.PushUnityEngineRenderTextureCreationFlags(L, UnityEngine.RenderTextureCreationFlags.CreatedFromScript);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AllowVerticalFlip"))
                {
                    translator.PushUnityEngineRenderTextureCreationFlags(L, UnityEngine.RenderTextureCreationFlags.AllowVerticalFlip);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NoResolvedColorSurface"))
                {
                    translator.PushUnityEngineRenderTextureCreationFlags(L, UnityEngine.RenderTextureCreationFlags.NoResolvedColorSurface);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DynamicallyScalable"))
                {
                    translator.PushUnityEngineRenderTextureCreationFlags(L, UnityEngine.RenderTextureCreationFlags.DynamicallyScalable);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BindMS"))
                {
                    translator.PushUnityEngineRenderTextureCreationFlags(L, UnityEngine.RenderTextureCreationFlags.BindMS);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.RenderTextureCreationFlags!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RenderTextureCreationFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderTextureReadWriteWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.RenderTextureReadWrite), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.RenderTextureReadWrite), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.RenderTextureReadWrite), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Default", UnityEngine.RenderTextureReadWrite.Default);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Linear", UnityEngine.RenderTextureReadWrite.Linear);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "sRGB", UnityEngine.RenderTextureReadWrite.sRGB);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.RenderTextureReadWrite), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderTextureReadWrite(L, (UnityEngine.RenderTextureReadWrite)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Default"))
                {
                    translator.PushUnityEngineRenderTextureReadWrite(L, UnityEngine.RenderTextureReadWrite.Default);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Linear"))
                {
                    translator.PushUnityEngineRenderTextureReadWrite(L, UnityEngine.RenderTextureReadWrite.Linear);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "sRGB"))
                {
                    translator.PushUnityEngineRenderTextureReadWrite(L, UnityEngine.RenderTextureReadWrite.sRGB);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.RenderTextureReadWrite!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RenderTextureReadWrite! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderTextureMemorylessWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.RenderTextureMemoryless), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.RenderTextureMemoryless), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.RenderTextureMemoryless), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.RenderTextureMemoryless.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Color", UnityEngine.RenderTextureMemoryless.Color);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Depth", UnityEngine.RenderTextureMemoryless.Depth);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MSAA", UnityEngine.RenderTextureMemoryless.MSAA);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.RenderTextureMemoryless), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderTextureMemoryless(L, (UnityEngine.RenderTextureMemoryless)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineRenderTextureMemoryless(L, UnityEngine.RenderTextureMemoryless.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Color"))
                {
                    translator.PushUnityEngineRenderTextureMemoryless(L, UnityEngine.RenderTextureMemoryless.Color);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Depth"))
                {
                    translator.PushUnityEngineRenderTextureMemoryless(L, UnityEngine.RenderTextureMemoryless.Depth);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MSAA"))
                {
                    translator.PushUnityEngineRenderTextureMemoryless(L, UnityEngine.RenderTextureMemoryless.MSAA);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.RenderTextureMemoryless!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RenderTextureMemoryless! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineHDRDisplaySupportFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.HDRDisplaySupportFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.HDRDisplaySupportFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.HDRDisplaySupportFlags), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.HDRDisplaySupportFlags.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Supported", UnityEngine.HDRDisplaySupportFlags.Supported);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuntimeSwitchable", UnityEngine.HDRDisplaySupportFlags.RuntimeSwitchable);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AutomaticTonemapping", UnityEngine.HDRDisplaySupportFlags.AutomaticTonemapping);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.HDRDisplaySupportFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineHDRDisplaySupportFlags(L, (UnityEngine.HDRDisplaySupportFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineHDRDisplaySupportFlags(L, UnityEngine.HDRDisplaySupportFlags.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Supported"))
                {
                    translator.PushUnityEngineHDRDisplaySupportFlags(L, UnityEngine.HDRDisplaySupportFlags.Supported);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RuntimeSwitchable"))
                {
                    translator.PushUnityEngineHDRDisplaySupportFlags(L, UnityEngine.HDRDisplaySupportFlags.RuntimeSwitchable);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AutomaticTonemapping"))
                {
                    translator.PushUnityEngineHDRDisplaySupportFlags(L, UnityEngine.HDRDisplaySupportFlags.AutomaticTonemapping);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.HDRDisplaySupportFlags!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.HDRDisplaySupportFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineLightmapsModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.LightmapsMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.LightmapsMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.LightmapsMode), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NonDirectional", UnityEngine.LightmapsMode.NonDirectional);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CombinedDirectional", UnityEngine.LightmapsMode.CombinedDirectional);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.LightmapsMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineLightmapsMode(L, (UnityEngine.LightmapsMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "NonDirectional"))
                {
                    translator.PushUnityEngineLightmapsMode(L, UnityEngine.LightmapsMode.NonDirectional);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CombinedDirectional"))
                {
                    translator.PushUnityEngineLightmapsMode(L, UnityEngine.LightmapsMode.CombinedDirectional);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.LightmapsMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.LightmapsMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineMaterialGlobalIlluminationFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.MaterialGlobalIlluminationFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.MaterialGlobalIlluminationFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.MaterialGlobalIlluminationFlags), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.MaterialGlobalIlluminationFlags.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RealtimeEmissive", UnityEngine.MaterialGlobalIlluminationFlags.RealtimeEmissive);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BakedEmissive", UnityEngine.MaterialGlobalIlluminationFlags.BakedEmissive);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EmissiveIsBlack", UnityEngine.MaterialGlobalIlluminationFlags.EmissiveIsBlack);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AnyEmissive", UnityEngine.MaterialGlobalIlluminationFlags.AnyEmissive);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.MaterialGlobalIlluminationFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineMaterialGlobalIlluminationFlags(L, (UnityEngine.MaterialGlobalIlluminationFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineMaterialGlobalIlluminationFlags(L, UnityEngine.MaterialGlobalIlluminationFlags.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RealtimeEmissive"))
                {
                    translator.PushUnityEngineMaterialGlobalIlluminationFlags(L, UnityEngine.MaterialGlobalIlluminationFlags.RealtimeEmissive);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BakedEmissive"))
                {
                    translator.PushUnityEngineMaterialGlobalIlluminationFlags(L, UnityEngine.MaterialGlobalIlluminationFlags.BakedEmissive);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "EmissiveIsBlack"))
                {
                    translator.PushUnityEngineMaterialGlobalIlluminationFlags(L, UnityEngine.MaterialGlobalIlluminationFlags.EmissiveIsBlack);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AnyEmissive"))
                {
                    translator.PushUnityEngineMaterialGlobalIlluminationFlags(L, UnityEngine.MaterialGlobalIlluminationFlags.AnyEmissive);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.MaterialGlobalIlluminationFlags!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.MaterialGlobalIlluminationFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineLightProbeProxyVolumeResolutionModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.LightProbeProxyVolume.ResolutionMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.LightProbeProxyVolume.ResolutionMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.LightProbeProxyVolume.ResolutionMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Automatic", UnityEngine.LightProbeProxyVolume.ResolutionMode.Automatic);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Custom", UnityEngine.LightProbeProxyVolume.ResolutionMode.Custom);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.LightProbeProxyVolume.ResolutionMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineLightProbeProxyVolumeResolutionMode(L, (UnityEngine.LightProbeProxyVolume.ResolutionMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Automatic"))
                {
                    translator.PushUnityEngineLightProbeProxyVolumeResolutionMode(L, UnityEngine.LightProbeProxyVolume.ResolutionMode.Automatic);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Custom"))
                {
                    translator.PushUnityEngineLightProbeProxyVolumeResolutionMode(L, UnityEngine.LightProbeProxyVolume.ResolutionMode.Custom);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.LightProbeProxyVolume.ResolutionMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.LightProbeProxyVolume.ResolutionMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineLightProbeProxyVolumeBoundingBoxModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.LightProbeProxyVolume.BoundingBoxMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.LightProbeProxyVolume.BoundingBoxMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.LightProbeProxyVolume.BoundingBoxMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AutomaticLocal", UnityEngine.LightProbeProxyVolume.BoundingBoxMode.AutomaticLocal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AutomaticWorld", UnityEngine.LightProbeProxyVolume.BoundingBoxMode.AutomaticWorld);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Custom", UnityEngine.LightProbeProxyVolume.BoundingBoxMode.Custom);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.LightProbeProxyVolume.BoundingBoxMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineLightProbeProxyVolumeBoundingBoxMode(L, (UnityEngine.LightProbeProxyVolume.BoundingBoxMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "AutomaticLocal"))
                {
                    translator.PushUnityEngineLightProbeProxyVolumeBoundingBoxMode(L, UnityEngine.LightProbeProxyVolume.BoundingBoxMode.AutomaticLocal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AutomaticWorld"))
                {
                    translator.PushUnityEngineLightProbeProxyVolumeBoundingBoxMode(L, UnityEngine.LightProbeProxyVolume.BoundingBoxMode.AutomaticWorld);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Custom"))
                {
                    translator.PushUnityEngineLightProbeProxyVolumeBoundingBoxMode(L, UnityEngine.LightProbeProxyVolume.BoundingBoxMode.Custom);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.LightProbeProxyVolume.BoundingBoxMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.LightProbeProxyVolume.BoundingBoxMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineLightProbeProxyVolumeProbePositionModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.LightProbeProxyVolume.ProbePositionMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.LightProbeProxyVolume.ProbePositionMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.LightProbeProxyVolume.ProbePositionMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CellCorner", UnityEngine.LightProbeProxyVolume.ProbePositionMode.CellCorner);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CellCenter", UnityEngine.LightProbeProxyVolume.ProbePositionMode.CellCenter);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.LightProbeProxyVolume.ProbePositionMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineLightProbeProxyVolumeProbePositionMode(L, (UnityEngine.LightProbeProxyVolume.ProbePositionMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "CellCorner"))
                {
                    translator.PushUnityEngineLightProbeProxyVolumeProbePositionMode(L, UnityEngine.LightProbeProxyVolume.ProbePositionMode.CellCorner);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CellCenter"))
                {
                    translator.PushUnityEngineLightProbeProxyVolumeProbePositionMode(L, UnityEngine.LightProbeProxyVolume.ProbePositionMode.CellCenter);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.LightProbeProxyVolume.ProbePositionMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.LightProbeProxyVolume.ProbePositionMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineLightProbeProxyVolumeRefreshModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.LightProbeProxyVolume.RefreshMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.LightProbeProxyVolume.RefreshMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.LightProbeProxyVolume.RefreshMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Automatic", UnityEngine.LightProbeProxyVolume.RefreshMode.Automatic);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EveryFrame", UnityEngine.LightProbeProxyVolume.RefreshMode.EveryFrame);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ViaScripting", UnityEngine.LightProbeProxyVolume.RefreshMode.ViaScripting);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.LightProbeProxyVolume.RefreshMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineLightProbeProxyVolumeRefreshMode(L, (UnityEngine.LightProbeProxyVolume.RefreshMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Automatic"))
                {
                    translator.PushUnityEngineLightProbeProxyVolumeRefreshMode(L, UnityEngine.LightProbeProxyVolume.RefreshMode.Automatic);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "EveryFrame"))
                {
                    translator.PushUnityEngineLightProbeProxyVolumeRefreshMode(L, UnityEngine.LightProbeProxyVolume.RefreshMode.EveryFrame);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ViaScripting"))
                {
                    translator.PushUnityEngineLightProbeProxyVolumeRefreshMode(L, UnityEngine.LightProbeProxyVolume.RefreshMode.ViaScripting);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.LightProbeProxyVolume.RefreshMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.LightProbeProxyVolume.RefreshMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineLightProbeProxyVolumeQualityModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.LightProbeProxyVolume.QualityMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.LightProbeProxyVolume.QualityMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.LightProbeProxyVolume.QualityMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Low", UnityEngine.LightProbeProxyVolume.QualityMode.Low);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", UnityEngine.LightProbeProxyVolume.QualityMode.Normal);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.LightProbeProxyVolume.QualityMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineLightProbeProxyVolumeQualityMode(L, (UnityEngine.LightProbeProxyVolume.QualityMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Low"))
                {
                    translator.PushUnityEngineLightProbeProxyVolumeQualityMode(L, UnityEngine.LightProbeProxyVolume.QualityMode.Low);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
                {
                    translator.PushUnityEngineLightProbeProxyVolumeQualityMode(L, UnityEngine.LightProbeProxyVolume.QualityMode.Normal);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.LightProbeProxyVolume.QualityMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.LightProbeProxyVolume.QualityMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineLightProbeProxyVolumeDataFormatWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.LightProbeProxyVolume.DataFormat), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.LightProbeProxyVolume.DataFormat), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.LightProbeProxyVolume.DataFormat), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HalfFloat", UnityEngine.LightProbeProxyVolume.DataFormat.HalfFloat);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Float", UnityEngine.LightProbeProxyVolume.DataFormat.Float);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.LightProbeProxyVolume.DataFormat), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineLightProbeProxyVolumeDataFormat(L, (UnityEngine.LightProbeProxyVolume.DataFormat)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "HalfFloat"))
                {
                    translator.PushUnityEngineLightProbeProxyVolumeDataFormat(L, UnityEngine.LightProbeProxyVolume.DataFormat.HalfFloat);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Float"))
                {
                    translator.PushUnityEngineLightProbeProxyVolumeDataFormat(L, UnityEngine.LightProbeProxyVolume.DataFormat.Float);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.LightProbeProxyVolume.DataFormat!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.LightProbeProxyVolume.DataFormat! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCustomRenderTextureInitializationSourceWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.CustomRenderTextureInitializationSource), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.CustomRenderTextureInitializationSource), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.CustomRenderTextureInitializationSource), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TextureAndColor", UnityEngine.CustomRenderTextureInitializationSource.TextureAndColor);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Material", UnityEngine.CustomRenderTextureInitializationSource.Material);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.CustomRenderTextureInitializationSource), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCustomRenderTextureInitializationSource(L, (UnityEngine.CustomRenderTextureInitializationSource)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "TextureAndColor"))
                {
                    translator.PushUnityEngineCustomRenderTextureInitializationSource(L, UnityEngine.CustomRenderTextureInitializationSource.TextureAndColor);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Material"))
                {
                    translator.PushUnityEngineCustomRenderTextureInitializationSource(L, UnityEngine.CustomRenderTextureInitializationSource.Material);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.CustomRenderTextureInitializationSource!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.CustomRenderTextureInitializationSource! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCustomRenderTextureUpdateModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.CustomRenderTextureUpdateMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.CustomRenderTextureUpdateMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.CustomRenderTextureUpdateMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OnLoad", UnityEngine.CustomRenderTextureUpdateMode.OnLoad);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Realtime", UnityEngine.CustomRenderTextureUpdateMode.Realtime);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OnDemand", UnityEngine.CustomRenderTextureUpdateMode.OnDemand);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.CustomRenderTextureUpdateMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCustomRenderTextureUpdateMode(L, (UnityEngine.CustomRenderTextureUpdateMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "OnLoad"))
                {
                    translator.PushUnityEngineCustomRenderTextureUpdateMode(L, UnityEngine.CustomRenderTextureUpdateMode.OnLoad);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Realtime"))
                {
                    translator.PushUnityEngineCustomRenderTextureUpdateMode(L, UnityEngine.CustomRenderTextureUpdateMode.Realtime);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "OnDemand"))
                {
                    translator.PushUnityEngineCustomRenderTextureUpdateMode(L, UnityEngine.CustomRenderTextureUpdateMode.OnDemand);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.CustomRenderTextureUpdateMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.CustomRenderTextureUpdateMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCustomRenderTextureUpdateZoneSpaceWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.CustomRenderTextureUpdateZoneSpace), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.CustomRenderTextureUpdateZoneSpace), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.CustomRenderTextureUpdateZoneSpace), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normalized", UnityEngine.CustomRenderTextureUpdateZoneSpace.Normalized);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pixel", UnityEngine.CustomRenderTextureUpdateZoneSpace.Pixel);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.CustomRenderTextureUpdateZoneSpace), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCustomRenderTextureUpdateZoneSpace(L, (UnityEngine.CustomRenderTextureUpdateZoneSpace)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Normalized"))
                {
                    translator.PushUnityEngineCustomRenderTextureUpdateZoneSpace(L, UnityEngine.CustomRenderTextureUpdateZoneSpace.Normalized);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Pixel"))
                {
                    translator.PushUnityEngineCustomRenderTextureUpdateZoneSpace(L, UnityEngine.CustomRenderTextureUpdateZoneSpace.Pixel);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.CustomRenderTextureUpdateZoneSpace!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.CustomRenderTextureUpdateZoneSpace! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineLineTextureModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.LineTextureMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.LineTextureMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.LineTextureMode), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Stretch", UnityEngine.LineTextureMode.Stretch);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Tile", UnityEngine.LineTextureMode.Tile);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DistributePerSegment", UnityEngine.LineTextureMode.DistributePerSegment);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RepeatPerSegment", UnityEngine.LineTextureMode.RepeatPerSegment);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.LineTextureMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineLineTextureMode(L, (UnityEngine.LineTextureMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Stretch"))
                {
                    translator.PushUnityEngineLineTextureMode(L, UnityEngine.LineTextureMode.Stretch);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Tile"))
                {
                    translator.PushUnityEngineLineTextureMode(L, UnityEngine.LineTextureMode.Tile);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DistributePerSegment"))
                {
                    translator.PushUnityEngineLineTextureMode(L, UnityEngine.LineTextureMode.DistributePerSegment);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RepeatPerSegment"))
                {
                    translator.PushUnityEngineLineTextureMode(L, UnityEngine.LineTextureMode.RepeatPerSegment);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.LineTextureMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.LineTextureMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineLineAlignmentWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.LineAlignment), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.LineAlignment), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.LineAlignment), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "View", UnityEngine.LineAlignment.View);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TransformZ", UnityEngine.LineAlignment.TransformZ);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.LineAlignment), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineLineAlignment(L, (UnityEngine.LineAlignment)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "View"))
                {
                    translator.PushUnityEngineLineAlignment(L, UnityEngine.LineAlignment.View);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TransformZ"))
                {
                    translator.PushUnityEngineLineAlignment(L, UnityEngine.LineAlignment.TransformZ);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.LineAlignment!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.LineAlignment! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineLODFadeModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.LODFadeMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.LODFadeMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.LODFadeMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.LODFadeMode.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CrossFade", UnityEngine.LODFadeMode.CrossFade);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SpeedTree", UnityEngine.LODFadeMode.SpeedTree);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.LODFadeMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineLODFadeMode(L, (UnityEngine.LODFadeMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineLODFadeMode(L, UnityEngine.LODFadeMode.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CrossFade"))
                {
                    translator.PushUnityEngineLODFadeMode(L, UnityEngine.LODFadeMode.CrossFade);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SpeedTree"))
                {
                    translator.PushUnityEngineLODFadeMode(L, UnityEngine.LODFadeMode.SpeedTree);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.LODFadeMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.LODFadeMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineKeyCodeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.KeyCode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.KeyCode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.KeyCode), L, null, 327, 0, 0);

            Utils.RegisterEnumType(L, typeof(UnityEngine.KeyCode));

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.KeyCode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineKeyCode(L, (UnityEngine.KeyCode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

                try
				{
                    translator.TranslateToEnumToTop(L, typeof(UnityEngine.KeyCode), 1);
				}
				catch (System.Exception e)
				{
					return LuaAPI.luaL_error(L, "cast to " + typeof(UnityEngine.KeyCode) + " exception:" + e);
				}

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.KeyCode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineGradientModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.GradientMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.GradientMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.GradientMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Blend", UnityEngine.GradientMode.Blend);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fixed", UnityEngine.GradientMode.Fixed);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.GradientMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineGradientMode(L, (UnityEngine.GradientMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Blend"))
                {
                    translator.PushUnityEngineGradientMode(L, UnityEngine.GradientMode.Blend);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Fixed"))
                {
                    translator.PushUnityEngineGradientMode(L, UnityEngine.GradientMode.Fixed);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.GradientMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.GradientMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRuntimeInitializeLoadTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.RuntimeInitializeLoadType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.RuntimeInitializeLoadType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.RuntimeInitializeLoadType), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AfterSceneLoad", UnityEngine.RuntimeInitializeLoadType.AfterSceneLoad);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BeforeSceneLoad", UnityEngine.RuntimeInitializeLoadType.BeforeSceneLoad);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AfterAssembliesLoaded", UnityEngine.RuntimeInitializeLoadType.AfterAssembliesLoaded);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BeforeSplashScreen", UnityEngine.RuntimeInitializeLoadType.BeforeSplashScreen);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SubsystemRegistration", UnityEngine.RuntimeInitializeLoadType.SubsystemRegistration);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.RuntimeInitializeLoadType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRuntimeInitializeLoadType(L, (UnityEngine.RuntimeInitializeLoadType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "AfterSceneLoad"))
                {
                    translator.PushUnityEngineRuntimeInitializeLoadType(L, UnityEngine.RuntimeInitializeLoadType.AfterSceneLoad);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BeforeSceneLoad"))
                {
                    translator.PushUnityEngineRuntimeInitializeLoadType(L, UnityEngine.RuntimeInitializeLoadType.BeforeSceneLoad);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AfterAssembliesLoaded"))
                {
                    translator.PushUnityEngineRuntimeInitializeLoadType(L, UnityEngine.RuntimeInitializeLoadType.AfterAssembliesLoaded);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BeforeSplashScreen"))
                {
                    translator.PushUnityEngineRuntimeInitializeLoadType(L, UnityEngine.RuntimeInitializeLoadType.BeforeSplashScreen);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SubsystemRegistration"))
                {
                    translator.PushUnityEngineRuntimeInitializeLoadType(L, UnityEngine.RuntimeInitializeLoadType.SubsystemRegistration);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.RuntimeInitializeLoadType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RuntimeInitializeLoadType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineHideFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.HideFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.HideFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.HideFlags), L, null, 10, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.HideFlags.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HideInHierarchy", UnityEngine.HideFlags.HideInHierarchy);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HideInInspector", UnityEngine.HideFlags.HideInInspector);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DontSaveInEditor", UnityEngine.HideFlags.DontSaveInEditor);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NotEditable", UnityEngine.HideFlags.NotEditable);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DontSaveInBuild", UnityEngine.HideFlags.DontSaveInBuild);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DontUnloadUnusedAsset", UnityEngine.HideFlags.DontUnloadUnusedAsset);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DontSave", UnityEngine.HideFlags.DontSave);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HideAndDontSave", UnityEngine.HideFlags.HideAndDontSave);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.HideFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineHideFlags(L, (UnityEngine.HideFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineHideFlags(L, UnityEngine.HideFlags.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "HideInHierarchy"))
                {
                    translator.PushUnityEngineHideFlags(L, UnityEngine.HideFlags.HideInHierarchy);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "HideInInspector"))
                {
                    translator.PushUnityEngineHideFlags(L, UnityEngine.HideFlags.HideInInspector);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DontSaveInEditor"))
                {
                    translator.PushUnityEngineHideFlags(L, UnityEngine.HideFlags.DontSaveInEditor);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NotEditable"))
                {
                    translator.PushUnityEngineHideFlags(L, UnityEngine.HideFlags.NotEditable);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DontSaveInBuild"))
                {
                    translator.PushUnityEngineHideFlags(L, UnityEngine.HideFlags.DontSaveInBuild);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DontUnloadUnusedAsset"))
                {
                    translator.PushUnityEngineHideFlags(L, UnityEngine.HideFlags.DontUnloadUnusedAsset);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DontSave"))
                {
                    translator.PushUnityEngineHideFlags(L, UnityEngine.HideFlags.DontSave);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "HideAndDontSave"))
                {
                    translator.PushUnityEngineHideFlags(L, UnityEngine.HideFlags.HideAndDontSave);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.HideFlags!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.HideFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineSnapAxisWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.SnapAxis), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.SnapAxis), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.SnapAxis), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.SnapAxis.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "X", UnityEngine.SnapAxis.X);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Y", UnityEngine.SnapAxis.Y);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Z", UnityEngine.SnapAxis.Z);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "All", UnityEngine.SnapAxis.All);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.SnapAxis), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineSnapAxis(L, (UnityEngine.SnapAxis)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineSnapAxis(L, UnityEngine.SnapAxis.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "X"))
                {
                    translator.PushUnityEngineSnapAxis(L, UnityEngine.SnapAxis.X);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Y"))
                {
                    translator.PushUnityEngineSnapAxis(L, UnityEngine.SnapAxis.Y);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Z"))
                {
                    translator.PushUnityEngineSnapAxis(L, UnityEngine.SnapAxis.Z);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "All"))
                {
                    translator.PushUnityEngineSnapAxis(L, UnityEngine.SnapAxis.All);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.SnapAxis!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.SnapAxis! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineBatteryStatusWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.BatteryStatus), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.BatteryStatus), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.BatteryStatus), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Unknown", UnityEngine.BatteryStatus.Unknown);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Charging", UnityEngine.BatteryStatus.Charging);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Discharging", UnityEngine.BatteryStatus.Discharging);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NotCharging", UnityEngine.BatteryStatus.NotCharging);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Full", UnityEngine.BatteryStatus.Full);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.BatteryStatus), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineBatteryStatus(L, (UnityEngine.BatteryStatus)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Unknown"))
                {
                    translator.PushUnityEngineBatteryStatus(L, UnityEngine.BatteryStatus.Unknown);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Charging"))
                {
                    translator.PushUnityEngineBatteryStatus(L, UnityEngine.BatteryStatus.Charging);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Discharging"))
                {
                    translator.PushUnityEngineBatteryStatus(L, UnityEngine.BatteryStatus.Discharging);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NotCharging"))
                {
                    translator.PushUnityEngineBatteryStatus(L, UnityEngine.BatteryStatus.NotCharging);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Full"))
                {
                    translator.PushUnityEngineBatteryStatus(L, UnityEngine.BatteryStatus.Full);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.BatteryStatus!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.BatteryStatus! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineOperatingSystemFamilyWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.OperatingSystemFamily), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.OperatingSystemFamily), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.OperatingSystemFamily), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Other", UnityEngine.OperatingSystemFamily.Other);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MacOSX", UnityEngine.OperatingSystemFamily.MacOSX);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Windows", UnityEngine.OperatingSystemFamily.Windows);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Linux", UnityEngine.OperatingSystemFamily.Linux);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.OperatingSystemFamily), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineOperatingSystemFamily(L, (UnityEngine.OperatingSystemFamily)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Other"))
                {
                    translator.PushUnityEngineOperatingSystemFamily(L, UnityEngine.OperatingSystemFamily.Other);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MacOSX"))
                {
                    translator.PushUnityEngineOperatingSystemFamily(L, UnityEngine.OperatingSystemFamily.MacOSX);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Windows"))
                {
                    translator.PushUnityEngineOperatingSystemFamily(L, UnityEngine.OperatingSystemFamily.Windows);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Linux"))
                {
                    translator.PushUnityEngineOperatingSystemFamily(L, UnityEngine.OperatingSystemFamily.Linux);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.OperatingSystemFamily!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.OperatingSystemFamily! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineDeviceTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.DeviceType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.DeviceType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.DeviceType), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Unknown", UnityEngine.DeviceType.Unknown);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Handheld", UnityEngine.DeviceType.Handheld);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Console", UnityEngine.DeviceType.Console);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Desktop", UnityEngine.DeviceType.Desktop);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.DeviceType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineDeviceType(L, (UnityEngine.DeviceType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Unknown"))
                {
                    translator.PushUnityEngineDeviceType(L, UnityEngine.DeviceType.Unknown);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Handheld"))
                {
                    translator.PushUnityEngineDeviceType(L, UnityEngine.DeviceType.Handheld);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Console"))
                {
                    translator.PushUnityEngineDeviceType(L, UnityEngine.DeviceType.Console);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Desktop"))
                {
                    translator.PushUnityEngineDeviceType(L, UnityEngine.DeviceType.Desktop);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.DeviceType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.DeviceType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineDrivenTransformPropertiesWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.DrivenTransformProperties), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.DrivenTransformProperties), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.DrivenTransformProperties), L, null, 26, 0, 0);

            Utils.RegisterEnumType(L, typeof(UnityEngine.DrivenTransformProperties));

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.DrivenTransformProperties), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineDrivenTransformProperties(L, (UnityEngine.DrivenTransformProperties)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

                try
				{
                    translator.TranslateToEnumToTop(L, typeof(UnityEngine.DrivenTransformProperties), 1);
				}
				catch (System.Exception e)
				{
					return LuaAPI.luaL_error(L, "cast to " + typeof(UnityEngine.DrivenTransformProperties) + " exception:" + e);
				}

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.DrivenTransformProperties! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRectTransformEdgeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.RectTransform.Edge), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.RectTransform.Edge), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.RectTransform.Edge), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Left", UnityEngine.RectTransform.Edge.Left);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Right", UnityEngine.RectTransform.Edge.Right);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Top", UnityEngine.RectTransform.Edge.Top);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Bottom", UnityEngine.RectTransform.Edge.Bottom);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.RectTransform.Edge), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRectTransformEdge(L, (UnityEngine.RectTransform.Edge)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Left"))
                {
                    translator.PushUnityEngineRectTransformEdge(L, UnityEngine.RectTransform.Edge.Left);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Right"))
                {
                    translator.PushUnityEngineRectTransformEdge(L, UnityEngine.RectTransform.Edge.Right);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Top"))
                {
                    translator.PushUnityEngineRectTransformEdge(L, UnityEngine.RectTransform.Edge.Top);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Bottom"))
                {
                    translator.PushUnityEngineRectTransformEdge(L, UnityEngine.RectTransform.Edge.Bottom);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.RectTransform.Edge!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RectTransform.Edge! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRectTransformAxisWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.RectTransform.Axis), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.RectTransform.Axis), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.RectTransform.Axis), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Horizontal", UnityEngine.RectTransform.Axis.Horizontal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vertical", UnityEngine.RectTransform.Axis.Vertical);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.RectTransform.Axis), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRectTransformAxis(L, (UnityEngine.RectTransform.Axis)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Horizontal"))
                {
                    translator.PushUnityEngineRectTransformAxis(L, UnityEngine.RectTransform.Axis.Horizontal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Vertical"))
                {
                    translator.PushUnityEngineRectTransformAxis(L, UnityEngine.RectTransform.Axis.Vertical);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.RectTransform.Axis!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RectTransform.Axis! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineSpriteDrawModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.SpriteDrawMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.SpriteDrawMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.SpriteDrawMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Simple", UnityEngine.SpriteDrawMode.Simple);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Sliced", UnityEngine.SpriteDrawMode.Sliced);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Tiled", UnityEngine.SpriteDrawMode.Tiled);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.SpriteDrawMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineSpriteDrawMode(L, (UnityEngine.SpriteDrawMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Simple"))
                {
                    translator.PushUnityEngineSpriteDrawMode(L, UnityEngine.SpriteDrawMode.Simple);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Sliced"))
                {
                    translator.PushUnityEngineSpriteDrawMode(L, UnityEngine.SpriteDrawMode.Sliced);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Tiled"))
                {
                    translator.PushUnityEngineSpriteDrawMode(L, UnityEngine.SpriteDrawMode.Tiled);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.SpriteDrawMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.SpriteDrawMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineSpriteTileModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.SpriteTileMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.SpriteTileMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.SpriteTileMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Continuous", UnityEngine.SpriteTileMode.Continuous);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Adaptive", UnityEngine.SpriteTileMode.Adaptive);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.SpriteTileMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineSpriteTileMode(L, (UnityEngine.SpriteTileMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Continuous"))
                {
                    translator.PushUnityEngineSpriteTileMode(L, UnityEngine.SpriteTileMode.Continuous);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Adaptive"))
                {
                    translator.PushUnityEngineSpriteTileMode(L, UnityEngine.SpriteTileMode.Adaptive);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.SpriteTileMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.SpriteTileMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineSpriteMaskInteractionWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.SpriteMaskInteraction), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.SpriteMaskInteraction), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.SpriteMaskInteraction), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.SpriteMaskInteraction.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VisibleInsideMask", UnityEngine.SpriteMaskInteraction.VisibleInsideMask);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VisibleOutsideMask", UnityEngine.SpriteMaskInteraction.VisibleOutsideMask);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.SpriteMaskInteraction), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineSpriteMaskInteraction(L, (UnityEngine.SpriteMaskInteraction)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineSpriteMaskInteraction(L, UnityEngine.SpriteMaskInteraction.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "VisibleInsideMask"))
                {
                    translator.PushUnityEngineSpriteMaskInteraction(L, UnityEngine.SpriteMaskInteraction.VisibleInsideMask);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "VisibleOutsideMask"))
                {
                    translator.PushUnityEngineSpriteMaskInteraction(L, UnityEngine.SpriteMaskInteraction.VisibleOutsideMask);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.SpriteMaskInteraction!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.SpriteMaskInteraction! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineSpriteMeshTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.SpriteMeshType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.SpriteMeshType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.SpriteMeshType), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FullRect", UnityEngine.SpriteMeshType.FullRect);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Tight", UnityEngine.SpriteMeshType.Tight);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.SpriteMeshType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineSpriteMeshType(L, (UnityEngine.SpriteMeshType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "FullRect"))
                {
                    translator.PushUnityEngineSpriteMeshType(L, UnityEngine.SpriteMeshType.FullRect);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Tight"))
                {
                    translator.PushUnityEngineSpriteMeshType(L, UnityEngine.SpriteMeshType.Tight);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.SpriteMeshType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.SpriteMeshType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineSpriteAlignmentWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.SpriteAlignment), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.SpriteAlignment), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.SpriteAlignment), L, null, 11, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Center", UnityEngine.SpriteAlignment.Center);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TopLeft", UnityEngine.SpriteAlignment.TopLeft);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TopCenter", UnityEngine.SpriteAlignment.TopCenter);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TopRight", UnityEngine.SpriteAlignment.TopRight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeftCenter", UnityEngine.SpriteAlignment.LeftCenter);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RightCenter", UnityEngine.SpriteAlignment.RightCenter);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BottomLeft", UnityEngine.SpriteAlignment.BottomLeft);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BottomCenter", UnityEngine.SpriteAlignment.BottomCenter);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BottomRight", UnityEngine.SpriteAlignment.BottomRight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Custom", UnityEngine.SpriteAlignment.Custom);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.SpriteAlignment), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineSpriteAlignment(L, (UnityEngine.SpriteAlignment)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Center"))
                {
                    translator.PushUnityEngineSpriteAlignment(L, UnityEngine.SpriteAlignment.Center);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TopLeft"))
                {
                    translator.PushUnityEngineSpriteAlignment(L, UnityEngine.SpriteAlignment.TopLeft);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TopCenter"))
                {
                    translator.PushUnityEngineSpriteAlignment(L, UnityEngine.SpriteAlignment.TopCenter);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TopRight"))
                {
                    translator.PushUnityEngineSpriteAlignment(L, UnityEngine.SpriteAlignment.TopRight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LeftCenter"))
                {
                    translator.PushUnityEngineSpriteAlignment(L, UnityEngine.SpriteAlignment.LeftCenter);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RightCenter"))
                {
                    translator.PushUnityEngineSpriteAlignment(L, UnityEngine.SpriteAlignment.RightCenter);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BottomLeft"))
                {
                    translator.PushUnityEngineSpriteAlignment(L, UnityEngine.SpriteAlignment.BottomLeft);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BottomCenter"))
                {
                    translator.PushUnityEngineSpriteAlignment(L, UnityEngine.SpriteAlignment.BottomCenter);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BottomRight"))
                {
                    translator.PushUnityEngineSpriteAlignment(L, UnityEngine.SpriteAlignment.BottomRight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Custom"))
                {
                    translator.PushUnityEngineSpriteAlignment(L, UnityEngine.SpriteAlignment.Custom);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.SpriteAlignment!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.SpriteAlignment! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineSpritePackingModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.SpritePackingMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.SpritePackingMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.SpritePackingMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Tight", UnityEngine.SpritePackingMode.Tight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Rectangle", UnityEngine.SpritePackingMode.Rectangle);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.SpritePackingMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineSpritePackingMode(L, (UnityEngine.SpritePackingMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Tight"))
                {
                    translator.PushUnityEngineSpritePackingMode(L, UnityEngine.SpritePackingMode.Tight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Rectangle"))
                {
                    translator.PushUnityEngineSpritePackingMode(L, UnityEngine.SpritePackingMode.Rectangle);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.SpritePackingMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.SpritePackingMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineSpritePackingRotationWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.SpritePackingRotation), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.SpritePackingRotation), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.SpritePackingRotation), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.SpritePackingRotation.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FlipHorizontal", UnityEngine.SpritePackingRotation.FlipHorizontal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FlipVertical", UnityEngine.SpritePackingRotation.FlipVertical);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Rotate180", UnityEngine.SpritePackingRotation.Rotate180);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Any", UnityEngine.SpritePackingRotation.Any);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.SpritePackingRotation), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineSpritePackingRotation(L, (UnityEngine.SpritePackingRotation)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineSpritePackingRotation(L, UnityEngine.SpritePackingRotation.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FlipHorizontal"))
                {
                    translator.PushUnityEngineSpritePackingRotation(L, UnityEngine.SpritePackingRotation.FlipHorizontal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FlipVertical"))
                {
                    translator.PushUnityEngineSpritePackingRotation(L, UnityEngine.SpritePackingRotation.FlipVertical);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Rotate180"))
                {
                    translator.PushUnityEngineSpritePackingRotation(L, UnityEngine.SpritePackingRotation.Rotate180);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Any"))
                {
                    translator.PushUnityEngineSpritePackingRotation(L, UnityEngine.SpritePackingRotation.Any);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.SpritePackingRotation!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.SpritePackingRotation! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineSpriteSortPointWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.SpriteSortPoint), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.SpriteSortPoint), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.SpriteSortPoint), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Center", UnityEngine.SpriteSortPoint.Center);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pivot", UnityEngine.SpriteSortPoint.Pivot);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.SpriteSortPoint), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineSpriteSortPoint(L, (UnityEngine.SpriteSortPoint)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Center"))
                {
                    translator.PushUnityEngineSpriteSortPoint(L, UnityEngine.SpriteSortPoint.Center);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Pivot"))
                {
                    translator.PushUnityEngineSpriteSortPoint(L, UnityEngine.SpriteSortPoint.Pivot);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.SpriteSortPoint!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.SpriteSortPoint! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineProfilingProfilerAreaWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Profiling.ProfilerArea), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Profiling.ProfilerArea), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Profiling.ProfilerArea), L, null, 15, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CPU", UnityEngine.Profiling.ProfilerArea.CPU);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GPU", UnityEngine.Profiling.ProfilerArea.GPU);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Rendering", UnityEngine.Profiling.ProfilerArea.Rendering);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Memory", UnityEngine.Profiling.ProfilerArea.Memory);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Audio", UnityEngine.Profiling.ProfilerArea.Audio);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Video", UnityEngine.Profiling.ProfilerArea.Video);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Physics", UnityEngine.Profiling.ProfilerArea.Physics);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Physics2D", UnityEngine.Profiling.ProfilerArea.Physics2D);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NetworkMessages", UnityEngine.Profiling.ProfilerArea.NetworkMessages);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NetworkOperations", UnityEngine.Profiling.ProfilerArea.NetworkOperations);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UI", UnityEngine.Profiling.ProfilerArea.UI);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UIDetails", UnityEngine.Profiling.ProfilerArea.UIDetails);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GlobalIllumination", UnityEngine.Profiling.ProfilerArea.GlobalIllumination);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VirtualTexturing", UnityEngine.Profiling.ProfilerArea.VirtualTexturing);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Profiling.ProfilerArea), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineProfilingProfilerArea(L, (UnityEngine.Profiling.ProfilerArea)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "CPU"))
                {
                    translator.PushUnityEngineProfilingProfilerArea(L, UnityEngine.Profiling.ProfilerArea.CPU);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "GPU"))
                {
                    translator.PushUnityEngineProfilingProfilerArea(L, UnityEngine.Profiling.ProfilerArea.GPU);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Rendering"))
                {
                    translator.PushUnityEngineProfilingProfilerArea(L, UnityEngine.Profiling.ProfilerArea.Rendering);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Memory"))
                {
                    translator.PushUnityEngineProfilingProfilerArea(L, UnityEngine.Profiling.ProfilerArea.Memory);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Audio"))
                {
                    translator.PushUnityEngineProfilingProfilerArea(L, UnityEngine.Profiling.ProfilerArea.Audio);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Video"))
                {
                    translator.PushUnityEngineProfilingProfilerArea(L, UnityEngine.Profiling.ProfilerArea.Video);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Physics"))
                {
                    translator.PushUnityEngineProfilingProfilerArea(L, UnityEngine.Profiling.ProfilerArea.Physics);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Physics2D"))
                {
                    translator.PushUnityEngineProfilingProfilerArea(L, UnityEngine.Profiling.ProfilerArea.Physics2D);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NetworkMessages"))
                {
                    translator.PushUnityEngineProfilingProfilerArea(L, UnityEngine.Profiling.ProfilerArea.NetworkMessages);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NetworkOperations"))
                {
                    translator.PushUnityEngineProfilingProfilerArea(L, UnityEngine.Profiling.ProfilerArea.NetworkOperations);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UI"))
                {
                    translator.PushUnityEngineProfilingProfilerArea(L, UnityEngine.Profiling.ProfilerArea.UI);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UIDetails"))
                {
                    translator.PushUnityEngineProfilingProfilerArea(L, UnityEngine.Profiling.ProfilerArea.UIDetails);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "GlobalIllumination"))
                {
                    translator.PushUnityEngineProfilingProfilerArea(L, UnityEngine.Profiling.ProfilerArea.GlobalIllumination);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "VirtualTexturing"))
                {
                    translator.PushUnityEngineProfilingProfilerArea(L, UnityEngine.Profiling.ProfilerArea.VirtualTexturing);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Profiling.ProfilerArea!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Profiling.ProfilerArea! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineProfilingMemoryExperimentalCaptureFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Profiling.Memory.Experimental.CaptureFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Profiling.Memory.Experimental.CaptureFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Profiling.Memory.Experimental.CaptureFlags), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ManagedObjects", UnityEngine.Profiling.Memory.Experimental.CaptureFlags.ManagedObjects);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NativeObjects", UnityEngine.Profiling.Memory.Experimental.CaptureFlags.NativeObjects);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NativeAllocations", UnityEngine.Profiling.Memory.Experimental.CaptureFlags.NativeAllocations);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NativeAllocationSites", UnityEngine.Profiling.Memory.Experimental.CaptureFlags.NativeAllocationSites);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NativeStackTraces", UnityEngine.Profiling.Memory.Experimental.CaptureFlags.NativeStackTraces);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Profiling.Memory.Experimental.CaptureFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineProfilingMemoryExperimentalCaptureFlags(L, (UnityEngine.Profiling.Memory.Experimental.CaptureFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "ManagedObjects"))
                {
                    translator.PushUnityEngineProfilingMemoryExperimentalCaptureFlags(L, UnityEngine.Profiling.Memory.Experimental.CaptureFlags.ManagedObjects);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NativeObjects"))
                {
                    translator.PushUnityEngineProfilingMemoryExperimentalCaptureFlags(L, UnityEngine.Profiling.Memory.Experimental.CaptureFlags.NativeObjects);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NativeAllocations"))
                {
                    translator.PushUnityEngineProfilingMemoryExperimentalCaptureFlags(L, UnityEngine.Profiling.Memory.Experimental.CaptureFlags.NativeAllocations);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NativeAllocationSites"))
                {
                    translator.PushUnityEngineProfilingMemoryExperimentalCaptureFlags(L, UnityEngine.Profiling.Memory.Experimental.CaptureFlags.NativeAllocationSites);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NativeStackTraces"))
                {
                    translator.PushUnityEngineProfilingMemoryExperimentalCaptureFlags(L, UnityEngine.Profiling.Memory.Experimental.CaptureFlags.NativeStackTraces);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Profiling.Memory.Experimental.CaptureFlags!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Profiling.Memory.Experimental.CaptureFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineEventsPersistentListenerModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Events.PersistentListenerMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Events.PersistentListenerMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Events.PersistentListenerMode), L, null, 8, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EventDefined", UnityEngine.Events.PersistentListenerMode.EventDefined);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Void", UnityEngine.Events.PersistentListenerMode.Void);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Object", UnityEngine.Events.PersistentListenerMode.Object);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Int", UnityEngine.Events.PersistentListenerMode.Int);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Float", UnityEngine.Events.PersistentListenerMode.Float);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "String", UnityEngine.Events.PersistentListenerMode.String);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Bool", UnityEngine.Events.PersistentListenerMode.Bool);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Events.PersistentListenerMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineEventsPersistentListenerMode(L, (UnityEngine.Events.PersistentListenerMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "EventDefined"))
                {
                    translator.PushUnityEngineEventsPersistentListenerMode(L, UnityEngine.Events.PersistentListenerMode.EventDefined);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Void"))
                {
                    translator.PushUnityEngineEventsPersistentListenerMode(L, UnityEngine.Events.PersistentListenerMode.Void);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Object"))
                {
                    translator.PushUnityEngineEventsPersistentListenerMode(L, UnityEngine.Events.PersistentListenerMode.Object);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Int"))
                {
                    translator.PushUnityEngineEventsPersistentListenerMode(L, UnityEngine.Events.PersistentListenerMode.Int);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Float"))
                {
                    translator.PushUnityEngineEventsPersistentListenerMode(L, UnityEngine.Events.PersistentListenerMode.Float);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "String"))
                {
                    translator.PushUnityEngineEventsPersistentListenerMode(L, UnityEngine.Events.PersistentListenerMode.String);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Bool"))
                {
                    translator.PushUnityEngineEventsPersistentListenerMode(L, UnityEngine.Events.PersistentListenerMode.Bool);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Events.PersistentListenerMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Events.PersistentListenerMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineEventsUnityEventCallStateWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Events.UnityEventCallState), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Events.UnityEventCallState), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Events.UnityEventCallState), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Off", UnityEngine.Events.UnityEventCallState.Off);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EditorAndRuntime", UnityEngine.Events.UnityEventCallState.EditorAndRuntime);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuntimeOnly", UnityEngine.Events.UnityEventCallState.RuntimeOnly);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Events.UnityEventCallState), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineEventsUnityEventCallState(L, (UnityEngine.Events.UnityEventCallState)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Off"))
                {
                    translator.PushUnityEngineEventsUnityEventCallState(L, UnityEngine.Events.UnityEventCallState.Off);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "EditorAndRuntime"))
                {
                    translator.PushUnityEngineEventsUnityEventCallState(L, UnityEngine.Events.UnityEventCallState.EditorAndRuntime);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RuntimeOnly"))
                {
                    translator.PushUnityEngineEventsUnityEventCallState(L, UnityEngine.Events.UnityEventCallState.RuntimeOnly);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Events.UnityEventCallState!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Events.UnityEventCallState! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineScriptingGarbageCollectorModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Scripting.GarbageCollector.Mode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Scripting.GarbageCollector.Mode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Scripting.GarbageCollector.Mode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Disabled", UnityEngine.Scripting.GarbageCollector.Mode.Disabled);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Enabled", UnityEngine.Scripting.GarbageCollector.Mode.Enabled);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Manual", UnityEngine.Scripting.GarbageCollector.Mode.Manual);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Scripting.GarbageCollector.Mode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineScriptingGarbageCollectorMode(L, (UnityEngine.Scripting.GarbageCollector.Mode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Disabled"))
                {
                    translator.PushUnityEngineScriptingGarbageCollectorMode(L, UnityEngine.Scripting.GarbageCollector.Mode.Disabled);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Enabled"))
                {
                    translator.PushUnityEngineScriptingGarbageCollectorMode(L, UnityEngine.Scripting.GarbageCollector.Mode.Enabled);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Manual"))
                {
                    translator.PushUnityEngineScriptingGarbageCollectorMode(L, UnityEngine.Scripting.GarbageCollector.Mode.Manual);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Scripting.GarbageCollector.Mode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Scripting.GarbageCollector.Mode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineSceneManagementLoadSceneModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.SceneManagement.LoadSceneMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.SceneManagement.LoadSceneMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.SceneManagement.LoadSceneMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Single", UnityEngine.SceneManagement.LoadSceneMode.Single);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Additive", UnityEngine.SceneManagement.LoadSceneMode.Additive);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.SceneManagement.LoadSceneMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineSceneManagementLoadSceneMode(L, (UnityEngine.SceneManagement.LoadSceneMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Single"))
                {
                    translator.PushUnityEngineSceneManagementLoadSceneMode(L, UnityEngine.SceneManagement.LoadSceneMode.Single);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Additive"))
                {
                    translator.PushUnityEngineSceneManagementLoadSceneMode(L, UnityEngine.SceneManagement.LoadSceneMode.Additive);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.SceneManagement.LoadSceneMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.SceneManagement.LoadSceneMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineSceneManagementLocalPhysicsModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.SceneManagement.LocalPhysicsMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.SceneManagement.LocalPhysicsMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.SceneManagement.LocalPhysicsMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.SceneManagement.LocalPhysicsMode.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Physics2D", UnityEngine.SceneManagement.LocalPhysicsMode.Physics2D);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Physics3D", UnityEngine.SceneManagement.LocalPhysicsMode.Physics3D);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.SceneManagement.LocalPhysicsMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineSceneManagementLocalPhysicsMode(L, (UnityEngine.SceneManagement.LocalPhysicsMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineSceneManagementLocalPhysicsMode(L, UnityEngine.SceneManagement.LocalPhysicsMode.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Physics2D"))
                {
                    translator.PushUnityEngineSceneManagementLocalPhysicsMode(L, UnityEngine.SceneManagement.LocalPhysicsMode.Physics2D);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Physics3D"))
                {
                    translator.PushUnityEngineSceneManagementLocalPhysicsMode(L, UnityEngine.SceneManagement.LocalPhysicsMode.Physics3D);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.SceneManagement.LocalPhysicsMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.SceneManagement.LocalPhysicsMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineSceneManagementUnloadSceneOptionsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.SceneManagement.UnloadSceneOptions), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.SceneManagement.UnloadSceneOptions), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.SceneManagement.UnloadSceneOptions), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.SceneManagement.UnloadSceneOptions.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnloadAllEmbeddedSceneObjects", UnityEngine.SceneManagement.UnloadSceneOptions.UnloadAllEmbeddedSceneObjects);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.SceneManagement.UnloadSceneOptions), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineSceneManagementUnloadSceneOptions(L, (UnityEngine.SceneManagement.UnloadSceneOptions)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineSceneManagementUnloadSceneOptions(L, UnityEngine.SceneManagement.UnloadSceneOptions.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UnloadAllEmbeddedSceneObjects"))
                {
                    translator.PushUnityEngineSceneManagementUnloadSceneOptions(L, UnityEngine.SceneManagement.UnloadSceneOptions.UnloadAllEmbeddedSceneObjects);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.SceneManagement.UnloadSceneOptions!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.SceneManagement.UnloadSceneOptions! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineNetworkingPlayerConnectionConnectionTargetWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Networking.PlayerConnection.ConnectionTarget), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Networking.PlayerConnection.ConnectionTarget), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Networking.PlayerConnection.ConnectionTarget), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Networking.PlayerConnection.ConnectionTarget.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Player", UnityEngine.Networking.PlayerConnection.ConnectionTarget.Player);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Editor", UnityEngine.Networking.PlayerConnection.ConnectionTarget.Editor);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Networking.PlayerConnection.ConnectionTarget), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineNetworkingPlayerConnectionConnectionTarget(L, (UnityEngine.Networking.PlayerConnection.ConnectionTarget)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineNetworkingPlayerConnectionConnectionTarget(L, UnityEngine.Networking.PlayerConnection.ConnectionTarget.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Player"))
                {
                    translator.PushUnityEngineNetworkingPlayerConnectionConnectionTarget(L, UnityEngine.Networking.PlayerConnection.ConnectionTarget.Player);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Editor"))
                {
                    translator.PushUnityEngineNetworkingPlayerConnectionConnectionTarget(L, UnityEngine.Networking.PlayerConnection.ConnectionTarget.Editor);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Networking.PlayerConnection.ConnectionTarget!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Networking.PlayerConnection.ConnectionTarget! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingSynchronisationStageWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.SynchronisationStage), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.SynchronisationStage), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.SynchronisationStage), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VertexProcessing", UnityEngine.Rendering.SynchronisationStage.VertexProcessing);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PixelProcessing", UnityEngine.Rendering.SynchronisationStage.PixelProcessing);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.SynchronisationStage), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingSynchronisationStage(L, (UnityEngine.Rendering.SynchronisationStage)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "VertexProcessing"))
                {
                    translator.PushUnityEngineRenderingSynchronisationStage(L, UnityEngine.Rendering.SynchronisationStage.VertexProcessing);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PixelProcessing"))
                {
                    translator.PushUnityEngineRenderingSynchronisationStage(L, UnityEngine.Rendering.SynchronisationStage.PixelProcessing);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.SynchronisationStage!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.SynchronisationStage! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingIndexFormatWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.IndexFormat), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.IndexFormat), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.IndexFormat), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UInt16", UnityEngine.Rendering.IndexFormat.UInt16);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UInt32", UnityEngine.Rendering.IndexFormat.UInt32);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.IndexFormat), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingIndexFormat(L, (UnityEngine.Rendering.IndexFormat)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "UInt16"))
                {
                    translator.PushUnityEngineRenderingIndexFormat(L, UnityEngine.Rendering.IndexFormat.UInt16);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UInt32"))
                {
                    translator.PushUnityEngineRenderingIndexFormat(L, UnityEngine.Rendering.IndexFormat.UInt32);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.IndexFormat!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.IndexFormat! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingMeshUpdateFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.MeshUpdateFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.MeshUpdateFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.MeshUpdateFlags), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Default", UnityEngine.Rendering.MeshUpdateFlags.Default);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DontValidateIndices", UnityEngine.Rendering.MeshUpdateFlags.DontValidateIndices);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DontResetBoneBounds", UnityEngine.Rendering.MeshUpdateFlags.DontResetBoneBounds);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DontNotifyMeshUsers", UnityEngine.Rendering.MeshUpdateFlags.DontNotifyMeshUsers);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DontRecalculateBounds", UnityEngine.Rendering.MeshUpdateFlags.DontRecalculateBounds);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.MeshUpdateFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingMeshUpdateFlags(L, (UnityEngine.Rendering.MeshUpdateFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Default"))
                {
                    translator.PushUnityEngineRenderingMeshUpdateFlags(L, UnityEngine.Rendering.MeshUpdateFlags.Default);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DontValidateIndices"))
                {
                    translator.PushUnityEngineRenderingMeshUpdateFlags(L, UnityEngine.Rendering.MeshUpdateFlags.DontValidateIndices);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DontResetBoneBounds"))
                {
                    translator.PushUnityEngineRenderingMeshUpdateFlags(L, UnityEngine.Rendering.MeshUpdateFlags.DontResetBoneBounds);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DontNotifyMeshUsers"))
                {
                    translator.PushUnityEngineRenderingMeshUpdateFlags(L, UnityEngine.Rendering.MeshUpdateFlags.DontNotifyMeshUsers);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DontRecalculateBounds"))
                {
                    translator.PushUnityEngineRenderingMeshUpdateFlags(L, UnityEngine.Rendering.MeshUpdateFlags.DontRecalculateBounds);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.MeshUpdateFlags!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.MeshUpdateFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingOpaqueSortModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.OpaqueSortMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.OpaqueSortMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.OpaqueSortMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Default", UnityEngine.Rendering.OpaqueSortMode.Default);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FrontToBack", UnityEngine.Rendering.OpaqueSortMode.FrontToBack);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NoDistanceSort", UnityEngine.Rendering.OpaqueSortMode.NoDistanceSort);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.OpaqueSortMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingOpaqueSortMode(L, (UnityEngine.Rendering.OpaqueSortMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Default"))
                {
                    translator.PushUnityEngineRenderingOpaqueSortMode(L, UnityEngine.Rendering.OpaqueSortMode.Default);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FrontToBack"))
                {
                    translator.PushUnityEngineRenderingOpaqueSortMode(L, UnityEngine.Rendering.OpaqueSortMode.FrontToBack);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NoDistanceSort"))
                {
                    translator.PushUnityEngineRenderingOpaqueSortMode(L, UnityEngine.Rendering.OpaqueSortMode.NoDistanceSort);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.OpaqueSortMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.OpaqueSortMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingRenderQueueWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.RenderQueue), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.RenderQueue), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.RenderQueue), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Background", UnityEngine.Rendering.RenderQueue.Background);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Geometry", UnityEngine.Rendering.RenderQueue.Geometry);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AlphaTest", UnityEngine.Rendering.RenderQueue.AlphaTest);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GeometryLast", UnityEngine.Rendering.RenderQueue.GeometryLast);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Transparent", UnityEngine.Rendering.RenderQueue.Transparent);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Overlay", UnityEngine.Rendering.RenderQueue.Overlay);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.RenderQueue), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingRenderQueue(L, (UnityEngine.Rendering.RenderQueue)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Background"))
                {
                    translator.PushUnityEngineRenderingRenderQueue(L, UnityEngine.Rendering.RenderQueue.Background);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Geometry"))
                {
                    translator.PushUnityEngineRenderingRenderQueue(L, UnityEngine.Rendering.RenderQueue.Geometry);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AlphaTest"))
                {
                    translator.PushUnityEngineRenderingRenderQueue(L, UnityEngine.Rendering.RenderQueue.AlphaTest);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "GeometryLast"))
                {
                    translator.PushUnityEngineRenderingRenderQueue(L, UnityEngine.Rendering.RenderQueue.GeometryLast);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Transparent"))
                {
                    translator.PushUnityEngineRenderingRenderQueue(L, UnityEngine.Rendering.RenderQueue.Transparent);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Overlay"))
                {
                    translator.PushUnityEngineRenderingRenderQueue(L, UnityEngine.Rendering.RenderQueue.Overlay);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.RenderQueue!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.RenderQueue! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingRenderBufferLoadActionWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.RenderBufferLoadAction), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.RenderBufferLoadAction), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.RenderBufferLoadAction), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Load", UnityEngine.Rendering.RenderBufferLoadAction.Load);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Clear", UnityEngine.Rendering.RenderBufferLoadAction.Clear);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DontCare", UnityEngine.Rendering.RenderBufferLoadAction.DontCare);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.RenderBufferLoadAction), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingRenderBufferLoadAction(L, (UnityEngine.Rendering.RenderBufferLoadAction)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Load"))
                {
                    translator.PushUnityEngineRenderingRenderBufferLoadAction(L, UnityEngine.Rendering.RenderBufferLoadAction.Load);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Clear"))
                {
                    translator.PushUnityEngineRenderingRenderBufferLoadAction(L, UnityEngine.Rendering.RenderBufferLoadAction.Clear);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DontCare"))
                {
                    translator.PushUnityEngineRenderingRenderBufferLoadAction(L, UnityEngine.Rendering.RenderBufferLoadAction.DontCare);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.RenderBufferLoadAction!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.RenderBufferLoadAction! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingRenderBufferStoreActionWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.RenderBufferStoreAction), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.RenderBufferStoreAction), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.RenderBufferStoreAction), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Store", UnityEngine.Rendering.RenderBufferStoreAction.Store);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Resolve", UnityEngine.Rendering.RenderBufferStoreAction.Resolve);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StoreAndResolve", UnityEngine.Rendering.RenderBufferStoreAction.StoreAndResolve);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DontCare", UnityEngine.Rendering.RenderBufferStoreAction.DontCare);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.RenderBufferStoreAction), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingRenderBufferStoreAction(L, (UnityEngine.Rendering.RenderBufferStoreAction)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Store"))
                {
                    translator.PushUnityEngineRenderingRenderBufferStoreAction(L, UnityEngine.Rendering.RenderBufferStoreAction.Store);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Resolve"))
                {
                    translator.PushUnityEngineRenderingRenderBufferStoreAction(L, UnityEngine.Rendering.RenderBufferStoreAction.Resolve);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "StoreAndResolve"))
                {
                    translator.PushUnityEngineRenderingRenderBufferStoreAction(L, UnityEngine.Rendering.RenderBufferStoreAction.StoreAndResolve);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DontCare"))
                {
                    translator.PushUnityEngineRenderingRenderBufferStoreAction(L, UnityEngine.Rendering.RenderBufferStoreAction.DontCare);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.RenderBufferStoreAction!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.RenderBufferStoreAction! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingFastMemoryFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.FastMemoryFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.FastMemoryFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.FastMemoryFlags), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Rendering.FastMemoryFlags.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SpillTop", UnityEngine.Rendering.FastMemoryFlags.SpillTop);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SpillBottom", UnityEngine.Rendering.FastMemoryFlags.SpillBottom);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.FastMemoryFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingFastMemoryFlags(L, (UnityEngine.Rendering.FastMemoryFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineRenderingFastMemoryFlags(L, UnityEngine.Rendering.FastMemoryFlags.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SpillTop"))
                {
                    translator.PushUnityEngineRenderingFastMemoryFlags(L, UnityEngine.Rendering.FastMemoryFlags.SpillTop);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SpillBottom"))
                {
                    translator.PushUnityEngineRenderingFastMemoryFlags(L, UnityEngine.Rendering.FastMemoryFlags.SpillBottom);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.FastMemoryFlags!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.FastMemoryFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingBlendModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.BlendMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.BlendMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.BlendMode), L, null, 12, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Zero", UnityEngine.Rendering.BlendMode.Zero);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "One", UnityEngine.Rendering.BlendMode.One);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DstColor", UnityEngine.Rendering.BlendMode.DstColor);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SrcColor", UnityEngine.Rendering.BlendMode.SrcColor);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OneMinusDstColor", UnityEngine.Rendering.BlendMode.OneMinusDstColor);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SrcAlpha", UnityEngine.Rendering.BlendMode.SrcAlpha);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OneMinusSrcColor", UnityEngine.Rendering.BlendMode.OneMinusSrcColor);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DstAlpha", UnityEngine.Rendering.BlendMode.DstAlpha);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OneMinusDstAlpha", UnityEngine.Rendering.BlendMode.OneMinusDstAlpha);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SrcAlphaSaturate", UnityEngine.Rendering.BlendMode.SrcAlphaSaturate);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OneMinusSrcAlpha", UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.BlendMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingBlendMode(L, (UnityEngine.Rendering.BlendMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Zero"))
                {
                    translator.PushUnityEngineRenderingBlendMode(L, UnityEngine.Rendering.BlendMode.Zero);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "One"))
                {
                    translator.PushUnityEngineRenderingBlendMode(L, UnityEngine.Rendering.BlendMode.One);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DstColor"))
                {
                    translator.PushUnityEngineRenderingBlendMode(L, UnityEngine.Rendering.BlendMode.DstColor);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SrcColor"))
                {
                    translator.PushUnityEngineRenderingBlendMode(L, UnityEngine.Rendering.BlendMode.SrcColor);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "OneMinusDstColor"))
                {
                    translator.PushUnityEngineRenderingBlendMode(L, UnityEngine.Rendering.BlendMode.OneMinusDstColor);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SrcAlpha"))
                {
                    translator.PushUnityEngineRenderingBlendMode(L, UnityEngine.Rendering.BlendMode.SrcAlpha);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "OneMinusSrcColor"))
                {
                    translator.PushUnityEngineRenderingBlendMode(L, UnityEngine.Rendering.BlendMode.OneMinusSrcColor);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DstAlpha"))
                {
                    translator.PushUnityEngineRenderingBlendMode(L, UnityEngine.Rendering.BlendMode.DstAlpha);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "OneMinusDstAlpha"))
                {
                    translator.PushUnityEngineRenderingBlendMode(L, UnityEngine.Rendering.BlendMode.OneMinusDstAlpha);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SrcAlphaSaturate"))
                {
                    translator.PushUnityEngineRenderingBlendMode(L, UnityEngine.Rendering.BlendMode.SrcAlphaSaturate);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "OneMinusSrcAlpha"))
                {
                    translator.PushUnityEngineRenderingBlendMode(L, UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.BlendMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.BlendMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingBlendOpWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.BlendOp), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.BlendOp), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.BlendOp), L, null, 37, 0, 0);

            Utils.RegisterEnumType(L, typeof(UnityEngine.Rendering.BlendOp));

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.BlendOp), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingBlendOp(L, (UnityEngine.Rendering.BlendOp)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

                try
				{
                    translator.TranslateToEnumToTop(L, typeof(UnityEngine.Rendering.BlendOp), 1);
				}
				catch (System.Exception e)
				{
					return LuaAPI.luaL_error(L, "cast to " + typeof(UnityEngine.Rendering.BlendOp) + " exception:" + e);
				}

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.BlendOp! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingCompareFunctionWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.CompareFunction), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.CompareFunction), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.CompareFunction), L, null, 10, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Disabled", UnityEngine.Rendering.CompareFunction.Disabled);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Never", UnityEngine.Rendering.CompareFunction.Never);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Less", UnityEngine.Rendering.CompareFunction.Less);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equal", UnityEngine.Rendering.CompareFunction.Equal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LessEqual", UnityEngine.Rendering.CompareFunction.LessEqual);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Greater", UnityEngine.Rendering.CompareFunction.Greater);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NotEqual", UnityEngine.Rendering.CompareFunction.NotEqual);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GreaterEqual", UnityEngine.Rendering.CompareFunction.GreaterEqual);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Always", UnityEngine.Rendering.CompareFunction.Always);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.CompareFunction), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingCompareFunction(L, (UnityEngine.Rendering.CompareFunction)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Disabled"))
                {
                    translator.PushUnityEngineRenderingCompareFunction(L, UnityEngine.Rendering.CompareFunction.Disabled);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Never"))
                {
                    translator.PushUnityEngineRenderingCompareFunction(L, UnityEngine.Rendering.CompareFunction.Never);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Less"))
                {
                    translator.PushUnityEngineRenderingCompareFunction(L, UnityEngine.Rendering.CompareFunction.Less);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Equal"))
                {
                    translator.PushUnityEngineRenderingCompareFunction(L, UnityEngine.Rendering.CompareFunction.Equal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LessEqual"))
                {
                    translator.PushUnityEngineRenderingCompareFunction(L, UnityEngine.Rendering.CompareFunction.LessEqual);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Greater"))
                {
                    translator.PushUnityEngineRenderingCompareFunction(L, UnityEngine.Rendering.CompareFunction.Greater);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NotEqual"))
                {
                    translator.PushUnityEngineRenderingCompareFunction(L, UnityEngine.Rendering.CompareFunction.NotEqual);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "GreaterEqual"))
                {
                    translator.PushUnityEngineRenderingCompareFunction(L, UnityEngine.Rendering.CompareFunction.GreaterEqual);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Always"))
                {
                    translator.PushUnityEngineRenderingCompareFunction(L, UnityEngine.Rendering.CompareFunction.Always);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.CompareFunction!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.CompareFunction! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingCullModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.CullMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.CullMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.CullMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Off", UnityEngine.Rendering.CullMode.Off);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Front", UnityEngine.Rendering.CullMode.Front);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Back", UnityEngine.Rendering.CullMode.Back);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.CullMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingCullMode(L, (UnityEngine.Rendering.CullMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Off"))
                {
                    translator.PushUnityEngineRenderingCullMode(L, UnityEngine.Rendering.CullMode.Off);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Front"))
                {
                    translator.PushUnityEngineRenderingCullMode(L, UnityEngine.Rendering.CullMode.Front);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Back"))
                {
                    translator.PushUnityEngineRenderingCullMode(L, UnityEngine.Rendering.CullMode.Back);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.CullMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.CullMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingColorWriteMaskWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.ColorWriteMask), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.ColorWriteMask), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.ColorWriteMask), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Alpha", UnityEngine.Rendering.ColorWriteMask.Alpha);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Blue", UnityEngine.Rendering.ColorWriteMask.Blue);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Green", UnityEngine.Rendering.ColorWriteMask.Green);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Red", UnityEngine.Rendering.ColorWriteMask.Red);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "All", UnityEngine.Rendering.ColorWriteMask.All);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.ColorWriteMask), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingColorWriteMask(L, (UnityEngine.Rendering.ColorWriteMask)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Alpha"))
                {
                    translator.PushUnityEngineRenderingColorWriteMask(L, UnityEngine.Rendering.ColorWriteMask.Alpha);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Blue"))
                {
                    translator.PushUnityEngineRenderingColorWriteMask(L, UnityEngine.Rendering.ColorWriteMask.Blue);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Green"))
                {
                    translator.PushUnityEngineRenderingColorWriteMask(L, UnityEngine.Rendering.ColorWriteMask.Green);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Red"))
                {
                    translator.PushUnityEngineRenderingColorWriteMask(L, UnityEngine.Rendering.ColorWriteMask.Red);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "All"))
                {
                    translator.PushUnityEngineRenderingColorWriteMask(L, UnityEngine.Rendering.ColorWriteMask.All);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.ColorWriteMask!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.ColorWriteMask! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingStencilOpWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.StencilOp), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.StencilOp), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.StencilOp), L, null, 9, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Keep", UnityEngine.Rendering.StencilOp.Keep);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Zero", UnityEngine.Rendering.StencilOp.Zero);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Replace", UnityEngine.Rendering.StencilOp.Replace);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IncrementSaturate", UnityEngine.Rendering.StencilOp.IncrementSaturate);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DecrementSaturate", UnityEngine.Rendering.StencilOp.DecrementSaturate);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Invert", UnityEngine.Rendering.StencilOp.Invert);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IncrementWrap", UnityEngine.Rendering.StencilOp.IncrementWrap);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DecrementWrap", UnityEngine.Rendering.StencilOp.DecrementWrap);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.StencilOp), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingStencilOp(L, (UnityEngine.Rendering.StencilOp)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Keep"))
                {
                    translator.PushUnityEngineRenderingStencilOp(L, UnityEngine.Rendering.StencilOp.Keep);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Zero"))
                {
                    translator.PushUnityEngineRenderingStencilOp(L, UnityEngine.Rendering.StencilOp.Zero);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Replace"))
                {
                    translator.PushUnityEngineRenderingStencilOp(L, UnityEngine.Rendering.StencilOp.Replace);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "IncrementSaturate"))
                {
                    translator.PushUnityEngineRenderingStencilOp(L, UnityEngine.Rendering.StencilOp.IncrementSaturate);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DecrementSaturate"))
                {
                    translator.PushUnityEngineRenderingStencilOp(L, UnityEngine.Rendering.StencilOp.DecrementSaturate);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Invert"))
                {
                    translator.PushUnityEngineRenderingStencilOp(L, UnityEngine.Rendering.StencilOp.Invert);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "IncrementWrap"))
                {
                    translator.PushUnityEngineRenderingStencilOp(L, UnityEngine.Rendering.StencilOp.IncrementWrap);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DecrementWrap"))
                {
                    translator.PushUnityEngineRenderingStencilOp(L, UnityEngine.Rendering.StencilOp.DecrementWrap);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.StencilOp!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.StencilOp! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingAmbientModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.AmbientMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.AmbientMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.AmbientMode), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Skybox", UnityEngine.Rendering.AmbientMode.Skybox);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Trilight", UnityEngine.Rendering.AmbientMode.Trilight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Flat", UnityEngine.Rendering.AmbientMode.Flat);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Custom", UnityEngine.Rendering.AmbientMode.Custom);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.AmbientMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingAmbientMode(L, (UnityEngine.Rendering.AmbientMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Skybox"))
                {
                    translator.PushUnityEngineRenderingAmbientMode(L, UnityEngine.Rendering.AmbientMode.Skybox);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Trilight"))
                {
                    translator.PushUnityEngineRenderingAmbientMode(L, UnityEngine.Rendering.AmbientMode.Trilight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Flat"))
                {
                    translator.PushUnityEngineRenderingAmbientMode(L, UnityEngine.Rendering.AmbientMode.Flat);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Custom"))
                {
                    translator.PushUnityEngineRenderingAmbientMode(L, UnityEngine.Rendering.AmbientMode.Custom);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.AmbientMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.AmbientMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingDefaultReflectionModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.DefaultReflectionMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.DefaultReflectionMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.DefaultReflectionMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Skybox", UnityEngine.Rendering.DefaultReflectionMode.Skybox);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Custom", UnityEngine.Rendering.DefaultReflectionMode.Custom);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.DefaultReflectionMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingDefaultReflectionMode(L, (UnityEngine.Rendering.DefaultReflectionMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Skybox"))
                {
                    translator.PushUnityEngineRenderingDefaultReflectionMode(L, UnityEngine.Rendering.DefaultReflectionMode.Skybox);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Custom"))
                {
                    translator.PushUnityEngineRenderingDefaultReflectionMode(L, UnityEngine.Rendering.DefaultReflectionMode.Custom);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.DefaultReflectionMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.DefaultReflectionMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingReflectionCubemapCompressionWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.ReflectionCubemapCompression), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.ReflectionCubemapCompression), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.ReflectionCubemapCompression), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Uncompressed", UnityEngine.Rendering.ReflectionCubemapCompression.Uncompressed);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Compressed", UnityEngine.Rendering.ReflectionCubemapCompression.Compressed);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Auto", UnityEngine.Rendering.ReflectionCubemapCompression.Auto);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.ReflectionCubemapCompression), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingReflectionCubemapCompression(L, (UnityEngine.Rendering.ReflectionCubemapCompression)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Uncompressed"))
                {
                    translator.PushUnityEngineRenderingReflectionCubemapCompression(L, UnityEngine.Rendering.ReflectionCubemapCompression.Uncompressed);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Compressed"))
                {
                    translator.PushUnityEngineRenderingReflectionCubemapCompression(L, UnityEngine.Rendering.ReflectionCubemapCompression.Compressed);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Auto"))
                {
                    translator.PushUnityEngineRenderingReflectionCubemapCompression(L, UnityEngine.Rendering.ReflectionCubemapCompression.Auto);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.ReflectionCubemapCompression!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.ReflectionCubemapCompression! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingCameraEventWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.CameraEvent), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.CameraEvent), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.CameraEvent), L, null, 26, 0, 0);

            Utils.RegisterEnumType(L, typeof(UnityEngine.Rendering.CameraEvent));

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.CameraEvent), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingCameraEvent(L, (UnityEngine.Rendering.CameraEvent)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

                try
				{
                    translator.TranslateToEnumToTop(L, typeof(UnityEngine.Rendering.CameraEvent), 1);
				}
				catch (System.Exception e)
				{
					return LuaAPI.luaL_error(L, "cast to " + typeof(UnityEngine.Rendering.CameraEvent) + " exception:" + e);
				}

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.CameraEvent! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingLightEventWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.LightEvent), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.LightEvent), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.LightEvent), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BeforeShadowMap", UnityEngine.Rendering.LightEvent.BeforeShadowMap);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AfterShadowMap", UnityEngine.Rendering.LightEvent.AfterShadowMap);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BeforeScreenspaceMask", UnityEngine.Rendering.LightEvent.BeforeScreenspaceMask);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AfterScreenspaceMask", UnityEngine.Rendering.LightEvent.AfterScreenspaceMask);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BeforeShadowMapPass", UnityEngine.Rendering.LightEvent.BeforeShadowMapPass);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AfterShadowMapPass", UnityEngine.Rendering.LightEvent.AfterShadowMapPass);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.LightEvent), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingLightEvent(L, (UnityEngine.Rendering.LightEvent)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "BeforeShadowMap"))
                {
                    translator.PushUnityEngineRenderingLightEvent(L, UnityEngine.Rendering.LightEvent.BeforeShadowMap);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AfterShadowMap"))
                {
                    translator.PushUnityEngineRenderingLightEvent(L, UnityEngine.Rendering.LightEvent.AfterShadowMap);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BeforeScreenspaceMask"))
                {
                    translator.PushUnityEngineRenderingLightEvent(L, UnityEngine.Rendering.LightEvent.BeforeScreenspaceMask);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AfterScreenspaceMask"))
                {
                    translator.PushUnityEngineRenderingLightEvent(L, UnityEngine.Rendering.LightEvent.AfterScreenspaceMask);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BeforeShadowMapPass"))
                {
                    translator.PushUnityEngineRenderingLightEvent(L, UnityEngine.Rendering.LightEvent.BeforeShadowMapPass);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AfterShadowMapPass"))
                {
                    translator.PushUnityEngineRenderingLightEvent(L, UnityEngine.Rendering.LightEvent.AfterShadowMapPass);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.LightEvent!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.LightEvent! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingShadowMapPassWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.ShadowMapPass), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.ShadowMapPass), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.ShadowMapPass), L, null, 15, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PointlightPositiveX", UnityEngine.Rendering.ShadowMapPass.PointlightPositiveX);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PointlightNegativeX", UnityEngine.Rendering.ShadowMapPass.PointlightNegativeX);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PointlightPositiveY", UnityEngine.Rendering.ShadowMapPass.PointlightPositiveY);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PointlightNegativeY", UnityEngine.Rendering.ShadowMapPass.PointlightNegativeY);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PointlightPositiveZ", UnityEngine.Rendering.ShadowMapPass.PointlightPositiveZ);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PointlightNegativeZ", UnityEngine.Rendering.ShadowMapPass.PointlightNegativeZ);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DirectionalCascade0", UnityEngine.Rendering.ShadowMapPass.DirectionalCascade0);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DirectionalCascade1", UnityEngine.Rendering.ShadowMapPass.DirectionalCascade1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DirectionalCascade2", UnityEngine.Rendering.ShadowMapPass.DirectionalCascade2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DirectionalCascade3", UnityEngine.Rendering.ShadowMapPass.DirectionalCascade3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Spotlight", UnityEngine.Rendering.ShadowMapPass.Spotlight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pointlight", UnityEngine.Rendering.ShadowMapPass.Pointlight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Directional", UnityEngine.Rendering.ShadowMapPass.Directional);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "All", UnityEngine.Rendering.ShadowMapPass.All);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.ShadowMapPass), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingShadowMapPass(L, (UnityEngine.Rendering.ShadowMapPass)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "PointlightPositiveX"))
                {
                    translator.PushUnityEngineRenderingShadowMapPass(L, UnityEngine.Rendering.ShadowMapPass.PointlightPositiveX);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PointlightNegativeX"))
                {
                    translator.PushUnityEngineRenderingShadowMapPass(L, UnityEngine.Rendering.ShadowMapPass.PointlightNegativeX);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PointlightPositiveY"))
                {
                    translator.PushUnityEngineRenderingShadowMapPass(L, UnityEngine.Rendering.ShadowMapPass.PointlightPositiveY);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PointlightNegativeY"))
                {
                    translator.PushUnityEngineRenderingShadowMapPass(L, UnityEngine.Rendering.ShadowMapPass.PointlightNegativeY);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PointlightPositiveZ"))
                {
                    translator.PushUnityEngineRenderingShadowMapPass(L, UnityEngine.Rendering.ShadowMapPass.PointlightPositiveZ);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PointlightNegativeZ"))
                {
                    translator.PushUnityEngineRenderingShadowMapPass(L, UnityEngine.Rendering.ShadowMapPass.PointlightNegativeZ);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DirectionalCascade0"))
                {
                    translator.PushUnityEngineRenderingShadowMapPass(L, UnityEngine.Rendering.ShadowMapPass.DirectionalCascade0);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DirectionalCascade1"))
                {
                    translator.PushUnityEngineRenderingShadowMapPass(L, UnityEngine.Rendering.ShadowMapPass.DirectionalCascade1);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DirectionalCascade2"))
                {
                    translator.PushUnityEngineRenderingShadowMapPass(L, UnityEngine.Rendering.ShadowMapPass.DirectionalCascade2);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DirectionalCascade3"))
                {
                    translator.PushUnityEngineRenderingShadowMapPass(L, UnityEngine.Rendering.ShadowMapPass.DirectionalCascade3);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Spotlight"))
                {
                    translator.PushUnityEngineRenderingShadowMapPass(L, UnityEngine.Rendering.ShadowMapPass.Spotlight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Pointlight"))
                {
                    translator.PushUnityEngineRenderingShadowMapPass(L, UnityEngine.Rendering.ShadowMapPass.Pointlight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Directional"))
                {
                    translator.PushUnityEngineRenderingShadowMapPass(L, UnityEngine.Rendering.ShadowMapPass.Directional);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "All"))
                {
                    translator.PushUnityEngineRenderingShadowMapPass(L, UnityEngine.Rendering.ShadowMapPass.All);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.ShadowMapPass!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.ShadowMapPass! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingBuiltinRenderTextureTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.BuiltinRenderTextureType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.BuiltinRenderTextureType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.BuiltinRenderTextureType), L, null, 24, 0, 0);

            Utils.RegisterEnumType(L, typeof(UnityEngine.Rendering.BuiltinRenderTextureType));

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.BuiltinRenderTextureType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingBuiltinRenderTextureType(L, (UnityEngine.Rendering.BuiltinRenderTextureType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

                try
				{
                    translator.TranslateToEnumToTop(L, typeof(UnityEngine.Rendering.BuiltinRenderTextureType), 1);
				}
				catch (System.Exception e)
				{
					return LuaAPI.luaL_error(L, "cast to " + typeof(UnityEngine.Rendering.BuiltinRenderTextureType) + " exception:" + e);
				}

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.BuiltinRenderTextureType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingPassTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.PassType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.PassType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.PassType), L, null, 15, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", UnityEngine.Rendering.PassType.Normal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vertex", UnityEngine.Rendering.PassType.Vertex);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VertexLM", UnityEngine.Rendering.PassType.VertexLM);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ForwardBase", UnityEngine.Rendering.PassType.ForwardBase);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ForwardAdd", UnityEngine.Rendering.PassType.ForwardAdd);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LightPrePassBase", UnityEngine.Rendering.PassType.LightPrePassBase);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LightPrePassFinal", UnityEngine.Rendering.PassType.LightPrePassFinal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ShadowCaster", UnityEngine.Rendering.PassType.ShadowCaster);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Deferred", UnityEngine.Rendering.PassType.Deferred);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Meta", UnityEngine.Rendering.PassType.Meta);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MotionVectors", UnityEngine.Rendering.PassType.MotionVectors);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ScriptableRenderPipeline", UnityEngine.Rendering.PassType.ScriptableRenderPipeline);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ScriptableRenderPipelineDefaultUnlit", UnityEngine.Rendering.PassType.ScriptableRenderPipelineDefaultUnlit);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.PassType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingPassType(L, (UnityEngine.Rendering.PassType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
                {
                    translator.PushUnityEngineRenderingPassType(L, UnityEngine.Rendering.PassType.Normal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Vertex"))
                {
                    translator.PushUnityEngineRenderingPassType(L, UnityEngine.Rendering.PassType.Vertex);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "VertexLM"))
                {
                    translator.PushUnityEngineRenderingPassType(L, UnityEngine.Rendering.PassType.VertexLM);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ForwardBase"))
                {
                    translator.PushUnityEngineRenderingPassType(L, UnityEngine.Rendering.PassType.ForwardBase);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ForwardAdd"))
                {
                    translator.PushUnityEngineRenderingPassType(L, UnityEngine.Rendering.PassType.ForwardAdd);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LightPrePassBase"))
                {
                    translator.PushUnityEngineRenderingPassType(L, UnityEngine.Rendering.PassType.LightPrePassBase);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LightPrePassFinal"))
                {
                    translator.PushUnityEngineRenderingPassType(L, UnityEngine.Rendering.PassType.LightPrePassFinal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ShadowCaster"))
                {
                    translator.PushUnityEngineRenderingPassType(L, UnityEngine.Rendering.PassType.ShadowCaster);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Deferred"))
                {
                    translator.PushUnityEngineRenderingPassType(L, UnityEngine.Rendering.PassType.Deferred);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Meta"))
                {
                    translator.PushUnityEngineRenderingPassType(L, UnityEngine.Rendering.PassType.Meta);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MotionVectors"))
                {
                    translator.PushUnityEngineRenderingPassType(L, UnityEngine.Rendering.PassType.MotionVectors);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ScriptableRenderPipeline"))
                {
                    translator.PushUnityEngineRenderingPassType(L, UnityEngine.Rendering.PassType.ScriptableRenderPipeline);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ScriptableRenderPipelineDefaultUnlit"))
                {
                    translator.PushUnityEngineRenderingPassType(L, UnityEngine.Rendering.PassType.ScriptableRenderPipelineDefaultUnlit);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.PassType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.PassType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingShadowCastingModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.ShadowCastingMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.ShadowCastingMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.ShadowCastingMode), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Off", UnityEngine.Rendering.ShadowCastingMode.Off);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "On", UnityEngine.Rendering.ShadowCastingMode.On);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TwoSided", UnityEngine.Rendering.ShadowCastingMode.TwoSided);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ShadowsOnly", UnityEngine.Rendering.ShadowCastingMode.ShadowsOnly);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.ShadowCastingMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingShadowCastingMode(L, (UnityEngine.Rendering.ShadowCastingMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Off"))
                {
                    translator.PushUnityEngineRenderingShadowCastingMode(L, UnityEngine.Rendering.ShadowCastingMode.Off);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "On"))
                {
                    translator.PushUnityEngineRenderingShadowCastingMode(L, UnityEngine.Rendering.ShadowCastingMode.On);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TwoSided"))
                {
                    translator.PushUnityEngineRenderingShadowCastingMode(L, UnityEngine.Rendering.ShadowCastingMode.TwoSided);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ShadowsOnly"))
                {
                    translator.PushUnityEngineRenderingShadowCastingMode(L, UnityEngine.Rendering.ShadowCastingMode.ShadowsOnly);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.ShadowCastingMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.ShadowCastingMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingLightShadowResolutionWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.LightShadowResolution), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.LightShadowResolution), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.LightShadowResolution), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FromQualitySettings", UnityEngine.Rendering.LightShadowResolution.FromQualitySettings);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Low", UnityEngine.Rendering.LightShadowResolution.Low);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Medium", UnityEngine.Rendering.LightShadowResolution.Medium);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "High", UnityEngine.Rendering.LightShadowResolution.High);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VeryHigh", UnityEngine.Rendering.LightShadowResolution.VeryHigh);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.LightShadowResolution), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingLightShadowResolution(L, (UnityEngine.Rendering.LightShadowResolution)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "FromQualitySettings"))
                {
                    translator.PushUnityEngineRenderingLightShadowResolution(L, UnityEngine.Rendering.LightShadowResolution.FromQualitySettings);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Low"))
                {
                    translator.PushUnityEngineRenderingLightShadowResolution(L, UnityEngine.Rendering.LightShadowResolution.Low);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Medium"))
                {
                    translator.PushUnityEngineRenderingLightShadowResolution(L, UnityEngine.Rendering.LightShadowResolution.Medium);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "High"))
                {
                    translator.PushUnityEngineRenderingLightShadowResolution(L, UnityEngine.Rendering.LightShadowResolution.High);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "VeryHigh"))
                {
                    translator.PushUnityEngineRenderingLightShadowResolution(L, UnityEngine.Rendering.LightShadowResolution.VeryHigh);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.LightShadowResolution!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.LightShadowResolution! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingGraphicsDeviceTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.GraphicsDeviceType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.GraphicsDeviceType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.GraphicsDeviceType), L, null, 25, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Direct3D11", UnityEngine.Rendering.GraphicsDeviceType.Direct3D11);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Null", UnityEngine.Rendering.GraphicsDeviceType.Null);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenGLES2", UnityEngine.Rendering.GraphicsDeviceType.OpenGLES2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenGLES3", UnityEngine.Rendering.GraphicsDeviceType.OpenGLES3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlayStation4", UnityEngine.Rendering.GraphicsDeviceType.PlayStation4);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "XboxOne", UnityEngine.Rendering.GraphicsDeviceType.XboxOne);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Metal", UnityEngine.Rendering.GraphicsDeviceType.Metal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenGLCore", UnityEngine.Rendering.GraphicsDeviceType.OpenGLCore);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Direct3D12", UnityEngine.Rendering.GraphicsDeviceType.Direct3D12);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vulkan", UnityEngine.Rendering.GraphicsDeviceType.Vulkan);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Switch", UnityEngine.Rendering.GraphicsDeviceType.Switch);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "XboxOneD3D12", UnityEngine.Rendering.GraphicsDeviceType.XboxOneD3D12);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GameCoreXboxOne", UnityEngine.Rendering.GraphicsDeviceType.GameCoreXboxOne);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GameCoreXboxSeries", UnityEngine.Rendering.GraphicsDeviceType.GameCoreXboxSeries);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlayStation5", UnityEngine.Rendering.GraphicsDeviceType.PlayStation5);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlayStation5NGGC", UnityEngine.Rendering.GraphicsDeviceType.PlayStation5NGGC);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.GraphicsDeviceType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingGraphicsDeviceType(L, (UnityEngine.Rendering.GraphicsDeviceType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Direct3D11"))
                {
                    translator.PushUnityEngineRenderingGraphicsDeviceType(L, UnityEngine.Rendering.GraphicsDeviceType.Direct3D11);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Null"))
                {
                    translator.PushUnityEngineRenderingGraphicsDeviceType(L, UnityEngine.Rendering.GraphicsDeviceType.Null);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenGLES2"))
                {
                    translator.PushUnityEngineRenderingGraphicsDeviceType(L, UnityEngine.Rendering.GraphicsDeviceType.OpenGLES2);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenGLES3"))
                {
                    translator.PushUnityEngineRenderingGraphicsDeviceType(L, UnityEngine.Rendering.GraphicsDeviceType.OpenGLES3);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PlayStation4"))
                {
                    translator.PushUnityEngineRenderingGraphicsDeviceType(L, UnityEngine.Rendering.GraphicsDeviceType.PlayStation4);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "XboxOne"))
                {
                    translator.PushUnityEngineRenderingGraphicsDeviceType(L, UnityEngine.Rendering.GraphicsDeviceType.XboxOne);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Metal"))
                {
                    translator.PushUnityEngineRenderingGraphicsDeviceType(L, UnityEngine.Rendering.GraphicsDeviceType.Metal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenGLCore"))
                {
                    translator.PushUnityEngineRenderingGraphicsDeviceType(L, UnityEngine.Rendering.GraphicsDeviceType.OpenGLCore);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Direct3D12"))
                {
                    translator.PushUnityEngineRenderingGraphicsDeviceType(L, UnityEngine.Rendering.GraphicsDeviceType.Direct3D12);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Vulkan"))
                {
                    translator.PushUnityEngineRenderingGraphicsDeviceType(L, UnityEngine.Rendering.GraphicsDeviceType.Vulkan);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Switch"))
                {
                    translator.PushUnityEngineRenderingGraphicsDeviceType(L, UnityEngine.Rendering.GraphicsDeviceType.Switch);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "XboxOneD3D12"))
                {
                    translator.PushUnityEngineRenderingGraphicsDeviceType(L, UnityEngine.Rendering.GraphicsDeviceType.XboxOneD3D12);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "GameCoreXboxOne"))
                {
                    translator.PushUnityEngineRenderingGraphicsDeviceType(L, UnityEngine.Rendering.GraphicsDeviceType.GameCoreXboxOne);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "GameCoreXboxSeries"))
                {
                    translator.PushUnityEngineRenderingGraphicsDeviceType(L, UnityEngine.Rendering.GraphicsDeviceType.GameCoreXboxSeries);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PlayStation5"))
                {
                    translator.PushUnityEngineRenderingGraphicsDeviceType(L, UnityEngine.Rendering.GraphicsDeviceType.PlayStation5);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PlayStation5NGGC"))
                {
                    translator.PushUnityEngineRenderingGraphicsDeviceType(L, UnityEngine.Rendering.GraphicsDeviceType.PlayStation5NGGC);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.GraphicsDeviceType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.GraphicsDeviceType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingGraphicsTierWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.GraphicsTier), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.GraphicsTier), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.GraphicsTier), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Tier1", UnityEngine.Rendering.GraphicsTier.Tier1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Tier2", UnityEngine.Rendering.GraphicsTier.Tier2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Tier3", UnityEngine.Rendering.GraphicsTier.Tier3);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.GraphicsTier), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingGraphicsTier(L, (UnityEngine.Rendering.GraphicsTier)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Tier1"))
                {
                    translator.PushUnityEngineRenderingGraphicsTier(L, UnityEngine.Rendering.GraphicsTier.Tier1);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Tier2"))
                {
                    translator.PushUnityEngineRenderingGraphicsTier(L, UnityEngine.Rendering.GraphicsTier.Tier2);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Tier3"))
                {
                    translator.PushUnityEngineRenderingGraphicsTier(L, UnityEngine.Rendering.GraphicsTier.Tier3);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.GraphicsTier!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.GraphicsTier! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingFormatSwizzleWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.FormatSwizzle), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.FormatSwizzle), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.FormatSwizzle), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FormatSwizzleR", UnityEngine.Rendering.FormatSwizzle.FormatSwizzleR);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FormatSwizzleG", UnityEngine.Rendering.FormatSwizzle.FormatSwizzleG);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FormatSwizzleB", UnityEngine.Rendering.FormatSwizzle.FormatSwizzleB);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FormatSwizzleA", UnityEngine.Rendering.FormatSwizzle.FormatSwizzleA);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FormatSwizzle0", UnityEngine.Rendering.FormatSwizzle.FormatSwizzle0);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FormatSwizzle1", UnityEngine.Rendering.FormatSwizzle.FormatSwizzle1);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.FormatSwizzle), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingFormatSwizzle(L, (UnityEngine.Rendering.FormatSwizzle)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "FormatSwizzleR"))
                {
                    translator.PushUnityEngineRenderingFormatSwizzle(L, UnityEngine.Rendering.FormatSwizzle.FormatSwizzleR);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FormatSwizzleG"))
                {
                    translator.PushUnityEngineRenderingFormatSwizzle(L, UnityEngine.Rendering.FormatSwizzle.FormatSwizzleG);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FormatSwizzleB"))
                {
                    translator.PushUnityEngineRenderingFormatSwizzle(L, UnityEngine.Rendering.FormatSwizzle.FormatSwizzleB);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FormatSwizzleA"))
                {
                    translator.PushUnityEngineRenderingFormatSwizzle(L, UnityEngine.Rendering.FormatSwizzle.FormatSwizzleA);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FormatSwizzle0"))
                {
                    translator.PushUnityEngineRenderingFormatSwizzle(L, UnityEngine.Rendering.FormatSwizzle.FormatSwizzle0);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FormatSwizzle1"))
                {
                    translator.PushUnityEngineRenderingFormatSwizzle(L, UnityEngine.Rendering.FormatSwizzle.FormatSwizzle1);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.FormatSwizzle!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.FormatSwizzle! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingRenderTargetFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.RenderTargetFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.RenderTargetFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.RenderTargetFlags), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Rendering.RenderTargetFlags.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReadOnlyDepth", UnityEngine.Rendering.RenderTargetFlags.ReadOnlyDepth);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReadOnlyStencil", UnityEngine.Rendering.RenderTargetFlags.ReadOnlyStencil);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReadOnlyDepthStencil", UnityEngine.Rendering.RenderTargetFlags.ReadOnlyDepthStencil);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.RenderTargetFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingRenderTargetFlags(L, (UnityEngine.Rendering.RenderTargetFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineRenderingRenderTargetFlags(L, UnityEngine.Rendering.RenderTargetFlags.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ReadOnlyDepth"))
                {
                    translator.PushUnityEngineRenderingRenderTargetFlags(L, UnityEngine.Rendering.RenderTargetFlags.ReadOnlyDepth);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ReadOnlyStencil"))
                {
                    translator.PushUnityEngineRenderingRenderTargetFlags(L, UnityEngine.Rendering.RenderTargetFlags.ReadOnlyStencil);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ReadOnlyDepthStencil"))
                {
                    translator.PushUnityEngineRenderingRenderTargetFlags(L, UnityEngine.Rendering.RenderTargetFlags.ReadOnlyDepthStencil);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.RenderTargetFlags!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.RenderTargetFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingReflectionProbeUsageWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.ReflectionProbeUsage), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.ReflectionProbeUsage), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.ReflectionProbeUsage), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Off", UnityEngine.Rendering.ReflectionProbeUsage.Off);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BlendProbes", UnityEngine.Rendering.ReflectionProbeUsage.BlendProbes);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BlendProbesAndSkybox", UnityEngine.Rendering.ReflectionProbeUsage.BlendProbesAndSkybox);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Simple", UnityEngine.Rendering.ReflectionProbeUsage.Simple);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.ReflectionProbeUsage), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingReflectionProbeUsage(L, (UnityEngine.Rendering.ReflectionProbeUsage)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Off"))
                {
                    translator.PushUnityEngineRenderingReflectionProbeUsage(L, UnityEngine.Rendering.ReflectionProbeUsage.Off);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BlendProbes"))
                {
                    translator.PushUnityEngineRenderingReflectionProbeUsage(L, UnityEngine.Rendering.ReflectionProbeUsage.BlendProbes);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BlendProbesAndSkybox"))
                {
                    translator.PushUnityEngineRenderingReflectionProbeUsage(L, UnityEngine.Rendering.ReflectionProbeUsage.BlendProbesAndSkybox);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Simple"))
                {
                    translator.PushUnityEngineRenderingReflectionProbeUsage(L, UnityEngine.Rendering.ReflectionProbeUsage.Simple);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.ReflectionProbeUsage!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.ReflectionProbeUsage! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingReflectionProbeTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.ReflectionProbeType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.ReflectionProbeType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.ReflectionProbeType), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Cube", UnityEngine.Rendering.ReflectionProbeType.Cube);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Card", UnityEngine.Rendering.ReflectionProbeType.Card);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.ReflectionProbeType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingReflectionProbeType(L, (UnityEngine.Rendering.ReflectionProbeType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Cube"))
                {
                    translator.PushUnityEngineRenderingReflectionProbeType(L, UnityEngine.Rendering.ReflectionProbeType.Cube);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Card"))
                {
                    translator.PushUnityEngineRenderingReflectionProbeType(L, UnityEngine.Rendering.ReflectionProbeType.Card);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.ReflectionProbeType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.ReflectionProbeType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingReflectionProbeClearFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.ReflectionProbeClearFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.ReflectionProbeClearFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.ReflectionProbeClearFlags), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Skybox", UnityEngine.Rendering.ReflectionProbeClearFlags.Skybox);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SolidColor", UnityEngine.Rendering.ReflectionProbeClearFlags.SolidColor);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.ReflectionProbeClearFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingReflectionProbeClearFlags(L, (UnityEngine.Rendering.ReflectionProbeClearFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Skybox"))
                {
                    translator.PushUnityEngineRenderingReflectionProbeClearFlags(L, UnityEngine.Rendering.ReflectionProbeClearFlags.Skybox);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SolidColor"))
                {
                    translator.PushUnityEngineRenderingReflectionProbeClearFlags(L, UnityEngine.Rendering.ReflectionProbeClearFlags.SolidColor);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.ReflectionProbeClearFlags!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.ReflectionProbeClearFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingReflectionProbeModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.ReflectionProbeMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.ReflectionProbeMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.ReflectionProbeMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Baked", UnityEngine.Rendering.ReflectionProbeMode.Baked);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Realtime", UnityEngine.Rendering.ReflectionProbeMode.Realtime);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Custom", UnityEngine.Rendering.ReflectionProbeMode.Custom);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.ReflectionProbeMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingReflectionProbeMode(L, (UnityEngine.Rendering.ReflectionProbeMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Baked"))
                {
                    translator.PushUnityEngineRenderingReflectionProbeMode(L, UnityEngine.Rendering.ReflectionProbeMode.Baked);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Realtime"))
                {
                    translator.PushUnityEngineRenderingReflectionProbeMode(L, UnityEngine.Rendering.ReflectionProbeMode.Realtime);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Custom"))
                {
                    translator.PushUnityEngineRenderingReflectionProbeMode(L, UnityEngine.Rendering.ReflectionProbeMode.Custom);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.ReflectionProbeMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.ReflectionProbeMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingReflectionProbeRefreshModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.ReflectionProbeRefreshMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.ReflectionProbeRefreshMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.ReflectionProbeRefreshMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OnAwake", UnityEngine.Rendering.ReflectionProbeRefreshMode.OnAwake);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EveryFrame", UnityEngine.Rendering.ReflectionProbeRefreshMode.EveryFrame);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ViaScripting", UnityEngine.Rendering.ReflectionProbeRefreshMode.ViaScripting);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.ReflectionProbeRefreshMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingReflectionProbeRefreshMode(L, (UnityEngine.Rendering.ReflectionProbeRefreshMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "OnAwake"))
                {
                    translator.PushUnityEngineRenderingReflectionProbeRefreshMode(L, UnityEngine.Rendering.ReflectionProbeRefreshMode.OnAwake);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "EveryFrame"))
                {
                    translator.PushUnityEngineRenderingReflectionProbeRefreshMode(L, UnityEngine.Rendering.ReflectionProbeRefreshMode.EveryFrame);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ViaScripting"))
                {
                    translator.PushUnityEngineRenderingReflectionProbeRefreshMode(L, UnityEngine.Rendering.ReflectionProbeRefreshMode.ViaScripting);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.ReflectionProbeRefreshMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.ReflectionProbeRefreshMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingReflectionProbeTimeSlicingModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.ReflectionProbeTimeSlicingMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.ReflectionProbeTimeSlicingMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.ReflectionProbeTimeSlicingMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AllFacesAtOnce", UnityEngine.Rendering.ReflectionProbeTimeSlicingMode.AllFacesAtOnce);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IndividualFaces", UnityEngine.Rendering.ReflectionProbeTimeSlicingMode.IndividualFaces);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NoTimeSlicing", UnityEngine.Rendering.ReflectionProbeTimeSlicingMode.NoTimeSlicing);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.ReflectionProbeTimeSlicingMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingReflectionProbeTimeSlicingMode(L, (UnityEngine.Rendering.ReflectionProbeTimeSlicingMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "AllFacesAtOnce"))
                {
                    translator.PushUnityEngineRenderingReflectionProbeTimeSlicingMode(L, UnityEngine.Rendering.ReflectionProbeTimeSlicingMode.AllFacesAtOnce);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "IndividualFaces"))
                {
                    translator.PushUnityEngineRenderingReflectionProbeTimeSlicingMode(L, UnityEngine.Rendering.ReflectionProbeTimeSlicingMode.IndividualFaces);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NoTimeSlicing"))
                {
                    translator.PushUnityEngineRenderingReflectionProbeTimeSlicingMode(L, UnityEngine.Rendering.ReflectionProbeTimeSlicingMode.NoTimeSlicing);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.ReflectionProbeTimeSlicingMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.ReflectionProbeTimeSlicingMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingShadowSamplingModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.ShadowSamplingMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.ShadowSamplingMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.ShadowSamplingMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CompareDepths", UnityEngine.Rendering.ShadowSamplingMode.CompareDepths);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RawDepth", UnityEngine.Rendering.ShadowSamplingMode.RawDepth);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Rendering.ShadowSamplingMode.None);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.ShadowSamplingMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingShadowSamplingMode(L, (UnityEngine.Rendering.ShadowSamplingMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "CompareDepths"))
                {
                    translator.PushUnityEngineRenderingShadowSamplingMode(L, UnityEngine.Rendering.ShadowSamplingMode.CompareDepths);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RawDepth"))
                {
                    translator.PushUnityEngineRenderingShadowSamplingMode(L, UnityEngine.Rendering.ShadowSamplingMode.RawDepth);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineRenderingShadowSamplingMode(L, UnityEngine.Rendering.ShadowSamplingMode.None);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.ShadowSamplingMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.ShadowSamplingMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingLightProbeUsageWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.LightProbeUsage), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.LightProbeUsage), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.LightProbeUsage), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Off", UnityEngine.Rendering.LightProbeUsage.Off);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BlendProbes", UnityEngine.Rendering.LightProbeUsage.BlendProbes);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UseProxyVolume", UnityEngine.Rendering.LightProbeUsage.UseProxyVolume);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CustomProvided", UnityEngine.Rendering.LightProbeUsage.CustomProvided);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.LightProbeUsage), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingLightProbeUsage(L, (UnityEngine.Rendering.LightProbeUsage)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Off"))
                {
                    translator.PushUnityEngineRenderingLightProbeUsage(L, UnityEngine.Rendering.LightProbeUsage.Off);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BlendProbes"))
                {
                    translator.PushUnityEngineRenderingLightProbeUsage(L, UnityEngine.Rendering.LightProbeUsage.BlendProbes);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UseProxyVolume"))
                {
                    translator.PushUnityEngineRenderingLightProbeUsage(L, UnityEngine.Rendering.LightProbeUsage.UseProxyVolume);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CustomProvided"))
                {
                    translator.PushUnityEngineRenderingLightProbeUsage(L, UnityEngine.Rendering.LightProbeUsage.CustomProvided);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.LightProbeUsage!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.LightProbeUsage! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingBuiltinShaderTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.BuiltinShaderType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.BuiltinShaderType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.BuiltinShaderType), L, null, 9, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DeferredShading", UnityEngine.Rendering.BuiltinShaderType.DeferredShading);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DeferredReflections", UnityEngine.Rendering.BuiltinShaderType.DeferredReflections);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LegacyDeferredLighting", UnityEngine.Rendering.BuiltinShaderType.LegacyDeferredLighting);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ScreenSpaceShadows", UnityEngine.Rendering.BuiltinShaderType.ScreenSpaceShadows);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DepthNormals", UnityEngine.Rendering.BuiltinShaderType.DepthNormals);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MotionVectors", UnityEngine.Rendering.BuiltinShaderType.MotionVectors);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LightHalo", UnityEngine.Rendering.BuiltinShaderType.LightHalo);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LensFlare", UnityEngine.Rendering.BuiltinShaderType.LensFlare);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.BuiltinShaderType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingBuiltinShaderType(L, (UnityEngine.Rendering.BuiltinShaderType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "DeferredShading"))
                {
                    translator.PushUnityEngineRenderingBuiltinShaderType(L, UnityEngine.Rendering.BuiltinShaderType.DeferredShading);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DeferredReflections"))
                {
                    translator.PushUnityEngineRenderingBuiltinShaderType(L, UnityEngine.Rendering.BuiltinShaderType.DeferredReflections);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LegacyDeferredLighting"))
                {
                    translator.PushUnityEngineRenderingBuiltinShaderType(L, UnityEngine.Rendering.BuiltinShaderType.LegacyDeferredLighting);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ScreenSpaceShadows"))
                {
                    translator.PushUnityEngineRenderingBuiltinShaderType(L, UnityEngine.Rendering.BuiltinShaderType.ScreenSpaceShadows);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DepthNormals"))
                {
                    translator.PushUnityEngineRenderingBuiltinShaderType(L, UnityEngine.Rendering.BuiltinShaderType.DepthNormals);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MotionVectors"))
                {
                    translator.PushUnityEngineRenderingBuiltinShaderType(L, UnityEngine.Rendering.BuiltinShaderType.MotionVectors);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LightHalo"))
                {
                    translator.PushUnityEngineRenderingBuiltinShaderType(L, UnityEngine.Rendering.BuiltinShaderType.LightHalo);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LensFlare"))
                {
                    translator.PushUnityEngineRenderingBuiltinShaderType(L, UnityEngine.Rendering.BuiltinShaderType.LensFlare);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.BuiltinShaderType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.BuiltinShaderType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingBuiltinShaderModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.BuiltinShaderMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.BuiltinShaderMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.BuiltinShaderMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Disabled", UnityEngine.Rendering.BuiltinShaderMode.Disabled);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UseBuiltin", UnityEngine.Rendering.BuiltinShaderMode.UseBuiltin);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UseCustom", UnityEngine.Rendering.BuiltinShaderMode.UseCustom);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.BuiltinShaderMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingBuiltinShaderMode(L, (UnityEngine.Rendering.BuiltinShaderMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Disabled"))
                {
                    translator.PushUnityEngineRenderingBuiltinShaderMode(L, UnityEngine.Rendering.BuiltinShaderMode.Disabled);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UseBuiltin"))
                {
                    translator.PushUnityEngineRenderingBuiltinShaderMode(L, UnityEngine.Rendering.BuiltinShaderMode.UseBuiltin);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UseCustom"))
                {
                    translator.PushUnityEngineRenderingBuiltinShaderMode(L, UnityEngine.Rendering.BuiltinShaderMode.UseCustom);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.BuiltinShaderMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.BuiltinShaderMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingBuiltinShaderDefineWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.BuiltinShaderDefine), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.BuiltinShaderDefine), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.BuiltinShaderDefine), L, null, 34, 0, 0);

            Utils.RegisterEnumType(L, typeof(UnityEngine.Rendering.BuiltinShaderDefine));

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.BuiltinShaderDefine), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingBuiltinShaderDefine(L, (UnityEngine.Rendering.BuiltinShaderDefine)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

                try
				{
                    translator.TranslateToEnumToTop(L, typeof(UnityEngine.Rendering.BuiltinShaderDefine), 1);
				}
				catch (System.Exception e)
				{
					return LuaAPI.luaL_error(L, "cast to " + typeof(UnityEngine.Rendering.BuiltinShaderDefine) + " exception:" + e);
				}

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.BuiltinShaderDefine! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingVideoShadersIncludeModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.VideoShadersIncludeMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.VideoShadersIncludeMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.VideoShadersIncludeMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Never", UnityEngine.Rendering.VideoShadersIncludeMode.Never);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Referenced", UnityEngine.Rendering.VideoShadersIncludeMode.Referenced);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Always", UnityEngine.Rendering.VideoShadersIncludeMode.Always);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.VideoShadersIncludeMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingVideoShadersIncludeMode(L, (UnityEngine.Rendering.VideoShadersIncludeMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Never"))
                {
                    translator.PushUnityEngineRenderingVideoShadersIncludeMode(L, UnityEngine.Rendering.VideoShadersIncludeMode.Never);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Referenced"))
                {
                    translator.PushUnityEngineRenderingVideoShadersIncludeMode(L, UnityEngine.Rendering.VideoShadersIncludeMode.Referenced);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Always"))
                {
                    translator.PushUnityEngineRenderingVideoShadersIncludeMode(L, UnityEngine.Rendering.VideoShadersIncludeMode.Always);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.VideoShadersIncludeMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.VideoShadersIncludeMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingTextureDimensionWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.TextureDimension), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.TextureDimension), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.TextureDimension), L, null, 9, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Unknown", UnityEngine.Rendering.TextureDimension.Unknown);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Rendering.TextureDimension.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Any", UnityEngine.Rendering.TextureDimension.Any);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Tex2D", UnityEngine.Rendering.TextureDimension.Tex2D);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Tex3D", UnityEngine.Rendering.TextureDimension.Tex3D);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Cube", UnityEngine.Rendering.TextureDimension.Cube);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Tex2DArray", UnityEngine.Rendering.TextureDimension.Tex2DArray);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CubeArray", UnityEngine.Rendering.TextureDimension.CubeArray);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.TextureDimension), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingTextureDimension(L, (UnityEngine.Rendering.TextureDimension)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Unknown"))
                {
                    translator.PushUnityEngineRenderingTextureDimension(L, UnityEngine.Rendering.TextureDimension.Unknown);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineRenderingTextureDimension(L, UnityEngine.Rendering.TextureDimension.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Any"))
                {
                    translator.PushUnityEngineRenderingTextureDimension(L, UnityEngine.Rendering.TextureDimension.Any);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Tex2D"))
                {
                    translator.PushUnityEngineRenderingTextureDimension(L, UnityEngine.Rendering.TextureDimension.Tex2D);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Tex3D"))
                {
                    translator.PushUnityEngineRenderingTextureDimension(L, UnityEngine.Rendering.TextureDimension.Tex3D);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Cube"))
                {
                    translator.PushUnityEngineRenderingTextureDimension(L, UnityEngine.Rendering.TextureDimension.Cube);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Tex2DArray"))
                {
                    translator.PushUnityEngineRenderingTextureDimension(L, UnityEngine.Rendering.TextureDimension.Tex2DArray);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CubeArray"))
                {
                    translator.PushUnityEngineRenderingTextureDimension(L, UnityEngine.Rendering.TextureDimension.CubeArray);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.TextureDimension!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.TextureDimension! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingCopyTextureSupportWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.CopyTextureSupport), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.CopyTextureSupport), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.CopyTextureSupport), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Rendering.CopyTextureSupport.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Basic", UnityEngine.Rendering.CopyTextureSupport.Basic);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Copy3D", UnityEngine.Rendering.CopyTextureSupport.Copy3D);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DifferentTypes", UnityEngine.Rendering.CopyTextureSupport.DifferentTypes);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TextureToRT", UnityEngine.Rendering.CopyTextureSupport.TextureToRT);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RTToTexture", UnityEngine.Rendering.CopyTextureSupport.RTToTexture);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.CopyTextureSupport), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingCopyTextureSupport(L, (UnityEngine.Rendering.CopyTextureSupport)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineRenderingCopyTextureSupport(L, UnityEngine.Rendering.CopyTextureSupport.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Basic"))
                {
                    translator.PushUnityEngineRenderingCopyTextureSupport(L, UnityEngine.Rendering.CopyTextureSupport.Basic);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Copy3D"))
                {
                    translator.PushUnityEngineRenderingCopyTextureSupport(L, UnityEngine.Rendering.CopyTextureSupport.Copy3D);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DifferentTypes"))
                {
                    translator.PushUnityEngineRenderingCopyTextureSupport(L, UnityEngine.Rendering.CopyTextureSupport.DifferentTypes);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TextureToRT"))
                {
                    translator.PushUnityEngineRenderingCopyTextureSupport(L, UnityEngine.Rendering.CopyTextureSupport.TextureToRT);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RTToTexture"))
                {
                    translator.PushUnityEngineRenderingCopyTextureSupport(L, UnityEngine.Rendering.CopyTextureSupport.RTToTexture);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.CopyTextureSupport!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.CopyTextureSupport! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingCameraHDRModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.CameraHDRMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.CameraHDRMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.CameraHDRMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FP16", UnityEngine.Rendering.CameraHDRMode.FP16);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "R11G11B10", UnityEngine.Rendering.CameraHDRMode.R11G11B10);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.CameraHDRMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingCameraHDRMode(L, (UnityEngine.Rendering.CameraHDRMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "FP16"))
                {
                    translator.PushUnityEngineRenderingCameraHDRMode(L, UnityEngine.Rendering.CameraHDRMode.FP16);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "R11G11B10"))
                {
                    translator.PushUnityEngineRenderingCameraHDRMode(L, UnityEngine.Rendering.CameraHDRMode.R11G11B10);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.CameraHDRMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.CameraHDRMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingRealtimeGICPUUsageWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.RealtimeGICPUUsage), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.RealtimeGICPUUsage), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.RealtimeGICPUUsage), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Low", UnityEngine.Rendering.RealtimeGICPUUsage.Low);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Medium", UnityEngine.Rendering.RealtimeGICPUUsage.Medium);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "High", UnityEngine.Rendering.RealtimeGICPUUsage.High);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Unlimited", UnityEngine.Rendering.RealtimeGICPUUsage.Unlimited);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.RealtimeGICPUUsage), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingRealtimeGICPUUsage(L, (UnityEngine.Rendering.RealtimeGICPUUsage)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Low"))
                {
                    translator.PushUnityEngineRenderingRealtimeGICPUUsage(L, UnityEngine.Rendering.RealtimeGICPUUsage.Low);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Medium"))
                {
                    translator.PushUnityEngineRenderingRealtimeGICPUUsage(L, UnityEngine.Rendering.RealtimeGICPUUsage.Medium);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "High"))
                {
                    translator.PushUnityEngineRenderingRealtimeGICPUUsage(L, UnityEngine.Rendering.RealtimeGICPUUsage.High);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Unlimited"))
                {
                    translator.PushUnityEngineRenderingRealtimeGICPUUsage(L, UnityEngine.Rendering.RealtimeGICPUUsage.Unlimited);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.RealtimeGICPUUsage!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.RealtimeGICPUUsage! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingComputeQueueTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.ComputeQueueType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.ComputeQueueType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.ComputeQueueType), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Default", UnityEngine.Rendering.ComputeQueueType.Default);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Background", UnityEngine.Rendering.ComputeQueueType.Background);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Urgent", UnityEngine.Rendering.ComputeQueueType.Urgent);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.ComputeQueueType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingComputeQueueType(L, (UnityEngine.Rendering.ComputeQueueType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Default"))
                {
                    translator.PushUnityEngineRenderingComputeQueueType(L, UnityEngine.Rendering.ComputeQueueType.Default);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Background"))
                {
                    translator.PushUnityEngineRenderingComputeQueueType(L, UnityEngine.Rendering.ComputeQueueType.Background);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Urgent"))
                {
                    translator.PushUnityEngineRenderingComputeQueueType(L, UnityEngine.Rendering.ComputeQueueType.Urgent);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.ComputeQueueType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.ComputeQueueType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingSinglePassStereoModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.SinglePassStereoMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.SinglePassStereoMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.SinglePassStereoMode), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Rendering.SinglePassStereoMode.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SideBySide", UnityEngine.Rendering.SinglePassStereoMode.SideBySide);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Instancing", UnityEngine.Rendering.SinglePassStereoMode.Instancing);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Multiview", UnityEngine.Rendering.SinglePassStereoMode.Multiview);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.SinglePassStereoMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingSinglePassStereoMode(L, (UnityEngine.Rendering.SinglePassStereoMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineRenderingSinglePassStereoMode(L, UnityEngine.Rendering.SinglePassStereoMode.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SideBySide"))
                {
                    translator.PushUnityEngineRenderingSinglePassStereoMode(L, UnityEngine.Rendering.SinglePassStereoMode.SideBySide);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Instancing"))
                {
                    translator.PushUnityEngineRenderingSinglePassStereoMode(L, UnityEngine.Rendering.SinglePassStereoMode.Instancing);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Multiview"))
                {
                    translator.PushUnityEngineRenderingSinglePassStereoMode(L, UnityEngine.Rendering.SinglePassStereoMode.Multiview);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.SinglePassStereoMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.SinglePassStereoMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingCommandBufferExecutionFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.CommandBufferExecutionFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.CommandBufferExecutionFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.CommandBufferExecutionFlags), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Rendering.CommandBufferExecutionFlags.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AsyncCompute", UnityEngine.Rendering.CommandBufferExecutionFlags.AsyncCompute);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.CommandBufferExecutionFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingCommandBufferExecutionFlags(L, (UnityEngine.Rendering.CommandBufferExecutionFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineRenderingCommandBufferExecutionFlags(L, UnityEngine.Rendering.CommandBufferExecutionFlags.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AsyncCompute"))
                {
                    translator.PushUnityEngineRenderingCommandBufferExecutionFlags(L, UnityEngine.Rendering.CommandBufferExecutionFlags.AsyncCompute);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.CommandBufferExecutionFlags!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.CommandBufferExecutionFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingRenderTextureSubElementWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.RenderTextureSubElement), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.RenderTextureSubElement), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.RenderTextureSubElement), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Color", UnityEngine.Rendering.RenderTextureSubElement.Color);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Depth", UnityEngine.Rendering.RenderTextureSubElement.Depth);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Stencil", UnityEngine.Rendering.RenderTextureSubElement.Stencil);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Default", UnityEngine.Rendering.RenderTextureSubElement.Default);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.RenderTextureSubElement), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingRenderTextureSubElement(L, (UnityEngine.Rendering.RenderTextureSubElement)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Color"))
                {
                    translator.PushUnityEngineRenderingRenderTextureSubElement(L, UnityEngine.Rendering.RenderTextureSubElement.Color);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Depth"))
                {
                    translator.PushUnityEngineRenderingRenderTextureSubElement(L, UnityEngine.Rendering.RenderTextureSubElement.Depth);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Stencil"))
                {
                    translator.PushUnityEngineRenderingRenderTextureSubElement(L, UnityEngine.Rendering.RenderTextureSubElement.Stencil);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Default"))
                {
                    translator.PushUnityEngineRenderingRenderTextureSubElement(L, UnityEngine.Rendering.RenderTextureSubElement.Default);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.RenderTextureSubElement!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.RenderTextureSubElement! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingRenderingThreadingModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.RenderingThreadingMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.RenderingThreadingMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.RenderingThreadingMode), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Direct", UnityEngine.Rendering.RenderingThreadingMode.Direct);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SingleThreaded", UnityEngine.Rendering.RenderingThreadingMode.SingleThreaded);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MultiThreaded", UnityEngine.Rendering.RenderingThreadingMode.MultiThreaded);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LegacyJobified", UnityEngine.Rendering.RenderingThreadingMode.LegacyJobified);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NativeGraphicsJobs", UnityEngine.Rendering.RenderingThreadingMode.NativeGraphicsJobs);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NativeGraphicsJobsWithoutRenderThread", UnityEngine.Rendering.RenderingThreadingMode.NativeGraphicsJobsWithoutRenderThread);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.RenderingThreadingMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingRenderingThreadingMode(L, (UnityEngine.Rendering.RenderingThreadingMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Direct"))
                {
                    translator.PushUnityEngineRenderingRenderingThreadingMode(L, UnityEngine.Rendering.RenderingThreadingMode.Direct);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SingleThreaded"))
                {
                    translator.PushUnityEngineRenderingRenderingThreadingMode(L, UnityEngine.Rendering.RenderingThreadingMode.SingleThreaded);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MultiThreaded"))
                {
                    translator.PushUnityEngineRenderingRenderingThreadingMode(L, UnityEngine.Rendering.RenderingThreadingMode.MultiThreaded);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LegacyJobified"))
                {
                    translator.PushUnityEngineRenderingRenderingThreadingMode(L, UnityEngine.Rendering.RenderingThreadingMode.LegacyJobified);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NativeGraphicsJobs"))
                {
                    translator.PushUnityEngineRenderingRenderingThreadingMode(L, UnityEngine.Rendering.RenderingThreadingMode.NativeGraphicsJobs);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NativeGraphicsJobsWithoutRenderThread"))
                {
                    translator.PushUnityEngineRenderingRenderingThreadingMode(L, UnityEngine.Rendering.RenderingThreadingMode.NativeGraphicsJobsWithoutRenderThread);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.RenderingThreadingMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.RenderingThreadingMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingOpenGLESVersionWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.OpenGLESVersion), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.OpenGLESVersion), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.OpenGLESVersion), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Rendering.OpenGLESVersion.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenGLES20", UnityEngine.Rendering.OpenGLESVersion.OpenGLES20);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenGLES30", UnityEngine.Rendering.OpenGLESVersion.OpenGLES30);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenGLES31", UnityEngine.Rendering.OpenGLESVersion.OpenGLES31);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenGLES31AEP", UnityEngine.Rendering.OpenGLESVersion.OpenGLES31AEP);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenGLES32", UnityEngine.Rendering.OpenGLESVersion.OpenGLES32);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.OpenGLESVersion), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingOpenGLESVersion(L, (UnityEngine.Rendering.OpenGLESVersion)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineRenderingOpenGLESVersion(L, UnityEngine.Rendering.OpenGLESVersion.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenGLES20"))
                {
                    translator.PushUnityEngineRenderingOpenGLESVersion(L, UnityEngine.Rendering.OpenGLESVersion.OpenGLES20);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenGLES30"))
                {
                    translator.PushUnityEngineRenderingOpenGLESVersion(L, UnityEngine.Rendering.OpenGLESVersion.OpenGLES30);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenGLES31"))
                {
                    translator.PushUnityEngineRenderingOpenGLESVersion(L, UnityEngine.Rendering.OpenGLESVersion.OpenGLES31);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenGLES31AEP"))
                {
                    translator.PushUnityEngineRenderingOpenGLESVersion(L, UnityEngine.Rendering.OpenGLESVersion.OpenGLES31AEP);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenGLES32"))
                {
                    translator.PushUnityEngineRenderingOpenGLESVersion(L, UnityEngine.Rendering.OpenGLESVersion.OpenGLES32);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.OpenGLESVersion!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.OpenGLESVersion! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingSynchronisationStageFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.SynchronisationStageFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.SynchronisationStageFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.SynchronisationStageFlags), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VertexProcessing", UnityEngine.Rendering.SynchronisationStageFlags.VertexProcessing);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PixelProcessing", UnityEngine.Rendering.SynchronisationStageFlags.PixelProcessing);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ComputeProcessing", UnityEngine.Rendering.SynchronisationStageFlags.ComputeProcessing);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AllGPUOperations", UnityEngine.Rendering.SynchronisationStageFlags.AllGPUOperations);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.SynchronisationStageFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingSynchronisationStageFlags(L, (UnityEngine.Rendering.SynchronisationStageFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "VertexProcessing"))
                {
                    translator.PushUnityEngineRenderingSynchronisationStageFlags(L, UnityEngine.Rendering.SynchronisationStageFlags.VertexProcessing);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PixelProcessing"))
                {
                    translator.PushUnityEngineRenderingSynchronisationStageFlags(L, UnityEngine.Rendering.SynchronisationStageFlags.PixelProcessing);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ComputeProcessing"))
                {
                    translator.PushUnityEngineRenderingSynchronisationStageFlags(L, UnityEngine.Rendering.SynchronisationStageFlags.ComputeProcessing);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AllGPUOperations"))
                {
                    translator.PushUnityEngineRenderingSynchronisationStageFlags(L, UnityEngine.Rendering.SynchronisationStageFlags.AllGPUOperations);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.SynchronisationStageFlags!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.SynchronisationStageFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingGraphicsFenceTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.GraphicsFenceType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.GraphicsFenceType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.GraphicsFenceType), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AsyncQueueSynchronisation", UnityEngine.Rendering.GraphicsFenceType.AsyncQueueSynchronisation);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CPUSynchronisation", UnityEngine.Rendering.GraphicsFenceType.CPUSynchronisation);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.GraphicsFenceType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingGraphicsFenceType(L, (UnityEngine.Rendering.GraphicsFenceType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "AsyncQueueSynchronisation"))
                {
                    translator.PushUnityEngineRenderingGraphicsFenceType(L, UnityEngine.Rendering.GraphicsFenceType.AsyncQueueSynchronisation);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CPUSynchronisation"))
                {
                    translator.PushUnityEngineRenderingGraphicsFenceType(L, UnityEngine.Rendering.GraphicsFenceType.CPUSynchronisation);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.GraphicsFenceType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.GraphicsFenceType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingSplashScreenStopBehaviorWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.SplashScreen.StopBehavior), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.SplashScreen.StopBehavior), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.SplashScreen.StopBehavior), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StopImmediate", UnityEngine.Rendering.SplashScreen.StopBehavior.StopImmediate);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FadeOut", UnityEngine.Rendering.SplashScreen.StopBehavior.FadeOut);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.SplashScreen.StopBehavior), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingSplashScreenStopBehavior(L, (UnityEngine.Rendering.SplashScreen.StopBehavior)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "StopImmediate"))
                {
                    translator.PushUnityEngineRenderingSplashScreenStopBehavior(L, UnityEngine.Rendering.SplashScreen.StopBehavior.StopImmediate);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FadeOut"))
                {
                    translator.PushUnityEngineRenderingSplashScreenStopBehavior(L, UnityEngine.Rendering.SplashScreen.StopBehavior.FadeOut);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.SplashScreen.StopBehavior!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.SplashScreen.StopBehavior! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingCullingOptionsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.CullingOptions), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.CullingOptions), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.CullingOptions), L, null, 9, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Rendering.CullingOptions.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ForceEvenIfCameraIsNotActive", UnityEngine.Rendering.CullingOptions.ForceEvenIfCameraIsNotActive);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OcclusionCull", UnityEngine.Rendering.CullingOptions.OcclusionCull);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NeedsLighting", UnityEngine.Rendering.CullingOptions.NeedsLighting);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NeedsReflectionProbes", UnityEngine.Rendering.CullingOptions.NeedsReflectionProbes);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Stereo", UnityEngine.Rendering.CullingOptions.Stereo);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DisablePerObjectCulling", UnityEngine.Rendering.CullingOptions.DisablePerObjectCulling);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ShadowCasters", UnityEngine.Rendering.CullingOptions.ShadowCasters);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.CullingOptions), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingCullingOptions(L, (UnityEngine.Rendering.CullingOptions)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineRenderingCullingOptions(L, UnityEngine.Rendering.CullingOptions.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ForceEvenIfCameraIsNotActive"))
                {
                    translator.PushUnityEngineRenderingCullingOptions(L, UnityEngine.Rendering.CullingOptions.ForceEvenIfCameraIsNotActive);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "OcclusionCull"))
                {
                    translator.PushUnityEngineRenderingCullingOptions(L, UnityEngine.Rendering.CullingOptions.OcclusionCull);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NeedsLighting"))
                {
                    translator.PushUnityEngineRenderingCullingOptions(L, UnityEngine.Rendering.CullingOptions.NeedsLighting);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NeedsReflectionProbes"))
                {
                    translator.PushUnityEngineRenderingCullingOptions(L, UnityEngine.Rendering.CullingOptions.NeedsReflectionProbes);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Stereo"))
                {
                    translator.PushUnityEngineRenderingCullingOptions(L, UnityEngine.Rendering.CullingOptions.Stereo);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DisablePerObjectCulling"))
                {
                    translator.PushUnityEngineRenderingCullingOptions(L, UnityEngine.Rendering.CullingOptions.DisablePerObjectCulling);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ShadowCasters"))
                {
                    translator.PushUnityEngineRenderingCullingOptions(L, UnityEngine.Rendering.CullingOptions.ShadowCasters);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.CullingOptions!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.CullingOptions! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingGizmoSubsetWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.GizmoSubset), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.GizmoSubset), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.GizmoSubset), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PreImageEffects", UnityEngine.Rendering.GizmoSubset.PreImageEffects);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PostImageEffects", UnityEngine.Rendering.GizmoSubset.PostImageEffects);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.GizmoSubset), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingGizmoSubset(L, (UnityEngine.Rendering.GizmoSubset)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "PreImageEffects"))
                {
                    translator.PushUnityEngineRenderingGizmoSubset(L, UnityEngine.Rendering.GizmoSubset.PreImageEffects);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PostImageEffects"))
                {
                    translator.PushUnityEngineRenderingGizmoSubset(L, UnityEngine.Rendering.GizmoSubset.PostImageEffects);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.GizmoSubset!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.GizmoSubset! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingPerObjectDataWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.PerObjectData), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.PerObjectData), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.PerObjectData), L, null, 13, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Rendering.PerObjectData.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LightProbe", UnityEngine.Rendering.PerObjectData.LightProbe);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReflectionProbes", UnityEngine.Rendering.PerObjectData.ReflectionProbes);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LightProbeProxyVolume", UnityEngine.Rendering.PerObjectData.LightProbeProxyVolume);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Lightmaps", UnityEngine.Rendering.PerObjectData.Lightmaps);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LightData", UnityEngine.Rendering.PerObjectData.LightData);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MotionVectors", UnityEngine.Rendering.PerObjectData.MotionVectors);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LightIndices", UnityEngine.Rendering.PerObjectData.LightIndices);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReflectionProbeData", UnityEngine.Rendering.PerObjectData.ReflectionProbeData);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OcclusionProbe", UnityEngine.Rendering.PerObjectData.OcclusionProbe);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OcclusionProbeProxyVolume", UnityEngine.Rendering.PerObjectData.OcclusionProbeProxyVolume);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ShadowMask", UnityEngine.Rendering.PerObjectData.ShadowMask);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.PerObjectData), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingPerObjectData(L, (UnityEngine.Rendering.PerObjectData)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineRenderingPerObjectData(L, UnityEngine.Rendering.PerObjectData.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LightProbe"))
                {
                    translator.PushUnityEngineRenderingPerObjectData(L, UnityEngine.Rendering.PerObjectData.LightProbe);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ReflectionProbes"))
                {
                    translator.PushUnityEngineRenderingPerObjectData(L, UnityEngine.Rendering.PerObjectData.ReflectionProbes);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LightProbeProxyVolume"))
                {
                    translator.PushUnityEngineRenderingPerObjectData(L, UnityEngine.Rendering.PerObjectData.LightProbeProxyVolume);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Lightmaps"))
                {
                    translator.PushUnityEngineRenderingPerObjectData(L, UnityEngine.Rendering.PerObjectData.Lightmaps);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LightData"))
                {
                    translator.PushUnityEngineRenderingPerObjectData(L, UnityEngine.Rendering.PerObjectData.LightData);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MotionVectors"))
                {
                    translator.PushUnityEngineRenderingPerObjectData(L, UnityEngine.Rendering.PerObjectData.MotionVectors);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LightIndices"))
                {
                    translator.PushUnityEngineRenderingPerObjectData(L, UnityEngine.Rendering.PerObjectData.LightIndices);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ReflectionProbeData"))
                {
                    translator.PushUnityEngineRenderingPerObjectData(L, UnityEngine.Rendering.PerObjectData.ReflectionProbeData);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "OcclusionProbe"))
                {
                    translator.PushUnityEngineRenderingPerObjectData(L, UnityEngine.Rendering.PerObjectData.OcclusionProbe);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "OcclusionProbeProxyVolume"))
                {
                    translator.PushUnityEngineRenderingPerObjectData(L, UnityEngine.Rendering.PerObjectData.OcclusionProbeProxyVolume);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ShadowMask"))
                {
                    translator.PushUnityEngineRenderingPerObjectData(L, UnityEngine.Rendering.PerObjectData.ShadowMask);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.PerObjectData!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.PerObjectData! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingReflectionProbeSortingCriteriaWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.ReflectionProbeSortingCriteria), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.ReflectionProbeSortingCriteria), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.ReflectionProbeSortingCriteria), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Rendering.ReflectionProbeSortingCriteria.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Importance", UnityEngine.Rendering.ReflectionProbeSortingCriteria.Importance);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Size", UnityEngine.Rendering.ReflectionProbeSortingCriteria.Size);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ImportanceThenSize", UnityEngine.Rendering.ReflectionProbeSortingCriteria.ImportanceThenSize);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.ReflectionProbeSortingCriteria), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingReflectionProbeSortingCriteria(L, (UnityEngine.Rendering.ReflectionProbeSortingCriteria)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineRenderingReflectionProbeSortingCriteria(L, UnityEngine.Rendering.ReflectionProbeSortingCriteria.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Importance"))
                {
                    translator.PushUnityEngineRenderingReflectionProbeSortingCriteria(L, UnityEngine.Rendering.ReflectionProbeSortingCriteria.Importance);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Size"))
                {
                    translator.PushUnityEngineRenderingReflectionProbeSortingCriteria(L, UnityEngine.Rendering.ReflectionProbeSortingCriteria.Size);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ImportanceThenSize"))
                {
                    translator.PushUnityEngineRenderingReflectionProbeSortingCriteria(L, UnityEngine.Rendering.ReflectionProbeSortingCriteria.ImportanceThenSize);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.ReflectionProbeSortingCriteria!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.ReflectionProbeSortingCriteria! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingRenderStateMaskWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.RenderStateMask), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.RenderStateMask), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.RenderStateMask), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Nothing", UnityEngine.Rendering.RenderStateMask.Nothing);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Blend", UnityEngine.Rendering.RenderStateMask.Blend);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Raster", UnityEngine.Rendering.RenderStateMask.Raster);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Depth", UnityEngine.Rendering.RenderStateMask.Depth);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Stencil", UnityEngine.Rendering.RenderStateMask.Stencil);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Everything", UnityEngine.Rendering.RenderStateMask.Everything);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.RenderStateMask), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingRenderStateMask(L, (UnityEngine.Rendering.RenderStateMask)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Nothing"))
                {
                    translator.PushUnityEngineRenderingRenderStateMask(L, UnityEngine.Rendering.RenderStateMask.Nothing);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Blend"))
                {
                    translator.PushUnityEngineRenderingRenderStateMask(L, UnityEngine.Rendering.RenderStateMask.Blend);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Raster"))
                {
                    translator.PushUnityEngineRenderingRenderStateMask(L, UnityEngine.Rendering.RenderStateMask.Raster);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Depth"))
                {
                    translator.PushUnityEngineRenderingRenderStateMask(L, UnityEngine.Rendering.RenderStateMask.Depth);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Stencil"))
                {
                    translator.PushUnityEngineRenderingRenderStateMask(L, UnityEngine.Rendering.RenderStateMask.Stencil);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Everything"))
                {
                    translator.PushUnityEngineRenderingRenderStateMask(L, UnityEngine.Rendering.RenderStateMask.Everything);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.RenderStateMask!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.RenderStateMask! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingSortingCriteriaWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.SortingCriteria), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.SortingCriteria), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.SortingCriteria), L, null, 11, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Rendering.SortingCriteria.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SortingLayer", UnityEngine.Rendering.SortingCriteria.SortingLayer);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RenderQueue", UnityEngine.Rendering.SortingCriteria.RenderQueue);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BackToFront", UnityEngine.Rendering.SortingCriteria.BackToFront);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "QuantizedFrontToBack", UnityEngine.Rendering.SortingCriteria.QuantizedFrontToBack);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OptimizeStateChanges", UnityEngine.Rendering.SortingCriteria.OptimizeStateChanges);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CanvasOrder", UnityEngine.Rendering.SortingCriteria.CanvasOrder);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RendererPriority", UnityEngine.Rendering.SortingCriteria.RendererPriority);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CommonOpaque", UnityEngine.Rendering.SortingCriteria.CommonOpaque);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CommonTransparent", UnityEngine.Rendering.SortingCriteria.CommonTransparent);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.SortingCriteria), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingSortingCriteria(L, (UnityEngine.Rendering.SortingCriteria)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineRenderingSortingCriteria(L, UnityEngine.Rendering.SortingCriteria.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SortingLayer"))
                {
                    translator.PushUnityEngineRenderingSortingCriteria(L, UnityEngine.Rendering.SortingCriteria.SortingLayer);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RenderQueue"))
                {
                    translator.PushUnityEngineRenderingSortingCriteria(L, UnityEngine.Rendering.SortingCriteria.RenderQueue);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BackToFront"))
                {
                    translator.PushUnityEngineRenderingSortingCriteria(L, UnityEngine.Rendering.SortingCriteria.BackToFront);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "QuantizedFrontToBack"))
                {
                    translator.PushUnityEngineRenderingSortingCriteria(L, UnityEngine.Rendering.SortingCriteria.QuantizedFrontToBack);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "OptimizeStateChanges"))
                {
                    translator.PushUnityEngineRenderingSortingCriteria(L, UnityEngine.Rendering.SortingCriteria.OptimizeStateChanges);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CanvasOrder"))
                {
                    translator.PushUnityEngineRenderingSortingCriteria(L, UnityEngine.Rendering.SortingCriteria.CanvasOrder);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RendererPriority"))
                {
                    translator.PushUnityEngineRenderingSortingCriteria(L, UnityEngine.Rendering.SortingCriteria.RendererPriority);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CommonOpaque"))
                {
                    translator.PushUnityEngineRenderingSortingCriteria(L, UnityEngine.Rendering.SortingCriteria.CommonOpaque);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CommonTransparent"))
                {
                    translator.PushUnityEngineRenderingSortingCriteria(L, UnityEngine.Rendering.SortingCriteria.CommonTransparent);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.SortingCriteria!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.SortingCriteria! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingDistanceMetricWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.DistanceMetric), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.DistanceMetric), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.DistanceMetric), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Perspective", UnityEngine.Rendering.DistanceMetric.Perspective);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Orthographic", UnityEngine.Rendering.DistanceMetric.Orthographic);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CustomAxis", UnityEngine.Rendering.DistanceMetric.CustomAxis);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.DistanceMetric), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingDistanceMetric(L, (UnityEngine.Rendering.DistanceMetric)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Perspective"))
                {
                    translator.PushUnityEngineRenderingDistanceMetric(L, UnityEngine.Rendering.DistanceMetric.Perspective);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Orthographic"))
                {
                    translator.PushUnityEngineRenderingDistanceMetric(L, UnityEngine.Rendering.DistanceMetric.Orthographic);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CustomAxis"))
                {
                    translator.PushUnityEngineRenderingDistanceMetric(L, UnityEngine.Rendering.DistanceMetric.CustomAxis);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.DistanceMetric!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.DistanceMetric! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingSupportedRenderingFeaturesReflectionProbeModesWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.SupportedRenderingFeatures.ReflectionProbeModes), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.SupportedRenderingFeatures.ReflectionProbeModes), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.SupportedRenderingFeatures.ReflectionProbeModes), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Rendering.SupportedRenderingFeatures.ReflectionProbeModes.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Rotation", UnityEngine.Rendering.SupportedRenderingFeatures.ReflectionProbeModes.Rotation);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.SupportedRenderingFeatures.ReflectionProbeModes), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingSupportedRenderingFeaturesReflectionProbeModes(L, (UnityEngine.Rendering.SupportedRenderingFeatures.ReflectionProbeModes)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineRenderingSupportedRenderingFeaturesReflectionProbeModes(L, UnityEngine.Rendering.SupportedRenderingFeatures.ReflectionProbeModes.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Rotation"))
                {
                    translator.PushUnityEngineRenderingSupportedRenderingFeaturesReflectionProbeModes(L, UnityEngine.Rendering.SupportedRenderingFeatures.ReflectionProbeModes.Rotation);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.SupportedRenderingFeatures.ReflectionProbeModes!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.SupportedRenderingFeatures.ReflectionProbeModes! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingSupportedRenderingFeaturesLightmapMixedBakeModesWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.SupportedRenderingFeatures.LightmapMixedBakeModes), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.SupportedRenderingFeatures.LightmapMixedBakeModes), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.SupportedRenderingFeatures.LightmapMixedBakeModes), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Rendering.SupportedRenderingFeatures.LightmapMixedBakeModes.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IndirectOnly", UnityEngine.Rendering.SupportedRenderingFeatures.LightmapMixedBakeModes.IndirectOnly);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Subtractive", UnityEngine.Rendering.SupportedRenderingFeatures.LightmapMixedBakeModes.Subtractive);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Shadowmask", UnityEngine.Rendering.SupportedRenderingFeatures.LightmapMixedBakeModes.Shadowmask);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.SupportedRenderingFeatures.LightmapMixedBakeModes), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingSupportedRenderingFeaturesLightmapMixedBakeModes(L, (UnityEngine.Rendering.SupportedRenderingFeatures.LightmapMixedBakeModes)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineRenderingSupportedRenderingFeaturesLightmapMixedBakeModes(L, UnityEngine.Rendering.SupportedRenderingFeatures.LightmapMixedBakeModes.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "IndirectOnly"))
                {
                    translator.PushUnityEngineRenderingSupportedRenderingFeaturesLightmapMixedBakeModes(L, UnityEngine.Rendering.SupportedRenderingFeatures.LightmapMixedBakeModes.IndirectOnly);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Subtractive"))
                {
                    translator.PushUnityEngineRenderingSupportedRenderingFeaturesLightmapMixedBakeModes(L, UnityEngine.Rendering.SupportedRenderingFeatures.LightmapMixedBakeModes.Subtractive);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Shadowmask"))
                {
                    translator.PushUnityEngineRenderingSupportedRenderingFeaturesLightmapMixedBakeModes(L, UnityEngine.Rendering.SupportedRenderingFeatures.LightmapMixedBakeModes.Shadowmask);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.SupportedRenderingFeatures.LightmapMixedBakeModes!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.SupportedRenderingFeatures.LightmapMixedBakeModes! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingShaderKeywordTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.ShaderKeywordType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.ShaderKeywordType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.ShaderKeywordType), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Rendering.ShaderKeywordType.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BuiltinDefault", UnityEngine.Rendering.ShaderKeywordType.BuiltinDefault);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BuiltinExtra", UnityEngine.Rendering.ShaderKeywordType.BuiltinExtra);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BuiltinAutoStripped", UnityEngine.Rendering.ShaderKeywordType.BuiltinAutoStripped);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UserDefined", UnityEngine.Rendering.ShaderKeywordType.UserDefined);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.ShaderKeywordType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingShaderKeywordType(L, (UnityEngine.Rendering.ShaderKeywordType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineRenderingShaderKeywordType(L, UnityEngine.Rendering.ShaderKeywordType.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BuiltinDefault"))
                {
                    translator.PushUnityEngineRenderingShaderKeywordType(L, UnityEngine.Rendering.ShaderKeywordType.BuiltinDefault);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BuiltinExtra"))
                {
                    translator.PushUnityEngineRenderingShaderKeywordType(L, UnityEngine.Rendering.ShaderKeywordType.BuiltinExtra);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BuiltinAutoStripped"))
                {
                    translator.PushUnityEngineRenderingShaderKeywordType(L, UnityEngine.Rendering.ShaderKeywordType.BuiltinAutoStripped);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UserDefined"))
                {
                    translator.PushUnityEngineRenderingShaderKeywordType(L, UnityEngine.Rendering.ShaderKeywordType.UserDefined);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.ShaderKeywordType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.ShaderKeywordType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingShaderPropertyTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.ShaderPropertyType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.ShaderPropertyType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.ShaderPropertyType), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Color", UnityEngine.Rendering.ShaderPropertyType.Color);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vector", UnityEngine.Rendering.ShaderPropertyType.Vector);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Float", UnityEngine.Rendering.ShaderPropertyType.Float);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Range", UnityEngine.Rendering.ShaderPropertyType.Range);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Texture", UnityEngine.Rendering.ShaderPropertyType.Texture);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.ShaderPropertyType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingShaderPropertyType(L, (UnityEngine.Rendering.ShaderPropertyType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Color"))
                {
                    translator.PushUnityEngineRenderingShaderPropertyType(L, UnityEngine.Rendering.ShaderPropertyType.Color);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Vector"))
                {
                    translator.PushUnityEngineRenderingShaderPropertyType(L, UnityEngine.Rendering.ShaderPropertyType.Vector);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Float"))
                {
                    translator.PushUnityEngineRenderingShaderPropertyType(L, UnityEngine.Rendering.ShaderPropertyType.Float);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Range"))
                {
                    translator.PushUnityEngineRenderingShaderPropertyType(L, UnityEngine.Rendering.ShaderPropertyType.Range);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Texture"))
                {
                    translator.PushUnityEngineRenderingShaderPropertyType(L, UnityEngine.Rendering.ShaderPropertyType.Texture);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.ShaderPropertyType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.ShaderPropertyType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingShaderPropertyFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.ShaderPropertyFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.ShaderPropertyFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.ShaderPropertyFlags), L, null, 11, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Rendering.ShaderPropertyFlags.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HideInInspector", UnityEngine.Rendering.ShaderPropertyFlags.HideInInspector);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PerRendererData", UnityEngine.Rendering.ShaderPropertyFlags.PerRendererData);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NoScaleOffset", UnityEngine.Rendering.ShaderPropertyFlags.NoScaleOffset);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", UnityEngine.Rendering.ShaderPropertyFlags.Normal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HDR", UnityEngine.Rendering.ShaderPropertyFlags.HDR);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Gamma", UnityEngine.Rendering.ShaderPropertyFlags.Gamma);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NonModifiableTextureData", UnityEngine.Rendering.ShaderPropertyFlags.NonModifiableTextureData);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MainTexture", UnityEngine.Rendering.ShaderPropertyFlags.MainTexture);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MainColor", UnityEngine.Rendering.ShaderPropertyFlags.MainColor);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.ShaderPropertyFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingShaderPropertyFlags(L, (UnityEngine.Rendering.ShaderPropertyFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineRenderingShaderPropertyFlags(L, UnityEngine.Rendering.ShaderPropertyFlags.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "HideInInspector"))
                {
                    translator.PushUnityEngineRenderingShaderPropertyFlags(L, UnityEngine.Rendering.ShaderPropertyFlags.HideInInspector);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PerRendererData"))
                {
                    translator.PushUnityEngineRenderingShaderPropertyFlags(L, UnityEngine.Rendering.ShaderPropertyFlags.PerRendererData);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NoScaleOffset"))
                {
                    translator.PushUnityEngineRenderingShaderPropertyFlags(L, UnityEngine.Rendering.ShaderPropertyFlags.NoScaleOffset);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
                {
                    translator.PushUnityEngineRenderingShaderPropertyFlags(L, UnityEngine.Rendering.ShaderPropertyFlags.Normal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "HDR"))
                {
                    translator.PushUnityEngineRenderingShaderPropertyFlags(L, UnityEngine.Rendering.ShaderPropertyFlags.HDR);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Gamma"))
                {
                    translator.PushUnityEngineRenderingShaderPropertyFlags(L, UnityEngine.Rendering.ShaderPropertyFlags.Gamma);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NonModifiableTextureData"))
                {
                    translator.PushUnityEngineRenderingShaderPropertyFlags(L, UnityEngine.Rendering.ShaderPropertyFlags.NonModifiableTextureData);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MainTexture"))
                {
                    translator.PushUnityEngineRenderingShaderPropertyFlags(L, UnityEngine.Rendering.ShaderPropertyFlags.MainTexture);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MainColor"))
                {
                    translator.PushUnityEngineRenderingShaderPropertyFlags(L, UnityEngine.Rendering.ShaderPropertyFlags.MainColor);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.ShaderPropertyFlags!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.ShaderPropertyFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEnginePlayablesFrameDataEvaluationTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Playables.FrameData.EvaluationType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Playables.FrameData.EvaluationType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Playables.FrameData.EvaluationType), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Evaluate", UnityEngine.Playables.FrameData.EvaluationType.Evaluate);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Playback", UnityEngine.Playables.FrameData.EvaluationType.Playback);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Playables.FrameData.EvaluationType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEnginePlayablesFrameDataEvaluationType(L, (UnityEngine.Playables.FrameData.EvaluationType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Evaluate"))
                {
                    translator.PushUnityEnginePlayablesFrameDataEvaluationType(L, UnityEngine.Playables.FrameData.EvaluationType.Evaluate);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Playback"))
                {
                    translator.PushUnityEnginePlayablesFrameDataEvaluationType(L, UnityEngine.Playables.FrameData.EvaluationType.Playback);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Playables.FrameData.EvaluationType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Playables.FrameData.EvaluationType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEnginePlayablesDirectorWrapModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Playables.DirectorWrapMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Playables.DirectorWrapMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Playables.DirectorWrapMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Hold", UnityEngine.Playables.DirectorWrapMode.Hold);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Loop", UnityEngine.Playables.DirectorWrapMode.Loop);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Playables.DirectorWrapMode.None);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Playables.DirectorWrapMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEnginePlayablesDirectorWrapMode(L, (UnityEngine.Playables.DirectorWrapMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Hold"))
                {
                    translator.PushUnityEnginePlayablesDirectorWrapMode(L, UnityEngine.Playables.DirectorWrapMode.Hold);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Loop"))
                {
                    translator.PushUnityEnginePlayablesDirectorWrapMode(L, UnityEngine.Playables.DirectorWrapMode.Loop);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEnginePlayablesDirectorWrapMode(L, UnityEngine.Playables.DirectorWrapMode.None);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Playables.DirectorWrapMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Playables.DirectorWrapMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEnginePlayablesPlayableTraversalModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Playables.PlayableTraversalMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Playables.PlayableTraversalMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Playables.PlayableTraversalMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mix", UnityEngine.Playables.PlayableTraversalMode.Mix);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Passthrough", UnityEngine.Playables.PlayableTraversalMode.Passthrough);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Playables.PlayableTraversalMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEnginePlayablesPlayableTraversalMode(L, (UnityEngine.Playables.PlayableTraversalMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Mix"))
                {
                    translator.PushUnityEnginePlayablesPlayableTraversalMode(L, UnityEngine.Playables.PlayableTraversalMode.Mix);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Passthrough"))
                {
                    translator.PushUnityEnginePlayablesPlayableTraversalMode(L, UnityEngine.Playables.PlayableTraversalMode.Passthrough);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Playables.PlayableTraversalMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Playables.PlayableTraversalMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEnginePlayablesDirectorUpdateModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Playables.DirectorUpdateMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Playables.DirectorUpdateMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Playables.DirectorUpdateMode), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DSPClock", UnityEngine.Playables.DirectorUpdateMode.DSPClock);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GameTime", UnityEngine.Playables.DirectorUpdateMode.GameTime);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnscaledGameTime", UnityEngine.Playables.DirectorUpdateMode.UnscaledGameTime);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Manual", UnityEngine.Playables.DirectorUpdateMode.Manual);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Playables.DirectorUpdateMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEnginePlayablesDirectorUpdateMode(L, (UnityEngine.Playables.DirectorUpdateMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "DSPClock"))
                {
                    translator.PushUnityEnginePlayablesDirectorUpdateMode(L, UnityEngine.Playables.DirectorUpdateMode.DSPClock);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "GameTime"))
                {
                    translator.PushUnityEnginePlayablesDirectorUpdateMode(L, UnityEngine.Playables.DirectorUpdateMode.GameTime);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UnscaledGameTime"))
                {
                    translator.PushUnityEnginePlayablesDirectorUpdateMode(L, UnityEngine.Playables.DirectorUpdateMode.UnscaledGameTime);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Manual"))
                {
                    translator.PushUnityEnginePlayablesDirectorUpdateMode(L, UnityEngine.Playables.DirectorUpdateMode.Manual);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Playables.DirectorUpdateMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Playables.DirectorUpdateMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEnginePlayablesPlayStateWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Playables.PlayState), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Playables.PlayState), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Playables.PlayState), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Paused", UnityEngine.Playables.PlayState.Paused);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Playing", UnityEngine.Playables.PlayState.Playing);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Playables.PlayState), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEnginePlayablesPlayState(L, (UnityEngine.Playables.PlayState)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Paused"))
                {
                    translator.PushUnityEnginePlayablesPlayState(L, UnityEngine.Playables.PlayState.Paused);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Playing"))
                {
                    translator.PushUnityEnginePlayablesPlayState(L, UnityEngine.Playables.PlayState.Playing);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Playables.PlayState!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Playables.PlayState! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineDiagnosticsForcedCrashCategoryWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Diagnostics.ForcedCrashCategory), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Diagnostics.ForcedCrashCategory), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Diagnostics.ForcedCrashCategory), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AccessViolation", UnityEngine.Diagnostics.ForcedCrashCategory.AccessViolation);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FatalError", UnityEngine.Diagnostics.ForcedCrashCategory.FatalError);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Abort", UnityEngine.Diagnostics.ForcedCrashCategory.Abort);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PureVirtualFunction", UnityEngine.Diagnostics.ForcedCrashCategory.PureVirtualFunction);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MonoAbort", UnityEngine.Diagnostics.ForcedCrashCategory.MonoAbort);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Diagnostics.ForcedCrashCategory), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineDiagnosticsForcedCrashCategory(L, (UnityEngine.Diagnostics.ForcedCrashCategory)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "AccessViolation"))
                {
                    translator.PushUnityEngineDiagnosticsForcedCrashCategory(L, UnityEngine.Diagnostics.ForcedCrashCategory.AccessViolation);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FatalError"))
                {
                    translator.PushUnityEngineDiagnosticsForcedCrashCategory(L, UnityEngine.Diagnostics.ForcedCrashCategory.FatalError);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Abort"))
                {
                    translator.PushUnityEngineDiagnosticsForcedCrashCategory(L, UnityEngine.Diagnostics.ForcedCrashCategory.Abort);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PureVirtualFunction"))
                {
                    translator.PushUnityEngineDiagnosticsForcedCrashCategory(L, UnityEngine.Diagnostics.ForcedCrashCategory.PureVirtualFunction);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MonoAbort"))
                {
                    translator.PushUnityEngineDiagnosticsForcedCrashCategory(L, UnityEngine.Diagnostics.ForcedCrashCategory.MonoAbort);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Diagnostics.ForcedCrashCategory!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Diagnostics.ForcedCrashCategory! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineGridLayoutCellLayoutWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.GridLayout.CellLayout), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.GridLayout.CellLayout), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.GridLayout.CellLayout), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Rectangle", UnityEngine.GridLayout.CellLayout.Rectangle);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Hexagon", UnityEngine.GridLayout.CellLayout.Hexagon);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Isometric", UnityEngine.GridLayout.CellLayout.Isometric);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IsometricZAsY", UnityEngine.GridLayout.CellLayout.IsometricZAsY);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.GridLayout.CellLayout), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineGridLayoutCellLayout(L, (UnityEngine.GridLayout.CellLayout)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Rectangle"))
                {
                    translator.PushUnityEngineGridLayoutCellLayout(L, UnityEngine.GridLayout.CellLayout.Rectangle);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Hexagon"))
                {
                    translator.PushUnityEngineGridLayoutCellLayout(L, UnityEngine.GridLayout.CellLayout.Hexagon);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Isometric"))
                {
                    translator.PushUnityEngineGridLayoutCellLayout(L, UnityEngine.GridLayout.CellLayout.Isometric);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "IsometricZAsY"))
                {
                    translator.PushUnityEngineGridLayoutCellLayout(L, UnityEngine.GridLayout.CellLayout.IsometricZAsY);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.GridLayout.CellLayout!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.GridLayout.CellLayout! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineGridLayoutCellSwizzleWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.GridLayout.CellSwizzle), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.GridLayout.CellSwizzle), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.GridLayout.CellSwizzle), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "XYZ", UnityEngine.GridLayout.CellSwizzle.XYZ);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "XZY", UnityEngine.GridLayout.CellSwizzle.XZY);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "YXZ", UnityEngine.GridLayout.CellSwizzle.YXZ);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "YZX", UnityEngine.GridLayout.CellSwizzle.YZX);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ZXY", UnityEngine.GridLayout.CellSwizzle.ZXY);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ZYX", UnityEngine.GridLayout.CellSwizzle.ZYX);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.GridLayout.CellSwizzle), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineGridLayoutCellSwizzle(L, (UnityEngine.GridLayout.CellSwizzle)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "XYZ"))
                {
                    translator.PushUnityEngineGridLayoutCellSwizzle(L, UnityEngine.GridLayout.CellSwizzle.XYZ);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "XZY"))
                {
                    translator.PushUnityEngineGridLayoutCellSwizzle(L, UnityEngine.GridLayout.CellSwizzle.XZY);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "YXZ"))
                {
                    translator.PushUnityEngineGridLayoutCellSwizzle(L, UnityEngine.GridLayout.CellSwizzle.YXZ);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "YZX"))
                {
                    translator.PushUnityEngineGridLayoutCellSwizzle(L, UnityEngine.GridLayout.CellSwizzle.YZX);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ZXY"))
                {
                    translator.PushUnityEngineGridLayoutCellSwizzle(L, UnityEngine.GridLayout.CellSwizzle.ZXY);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ZYX"))
                {
                    translator.PushUnityEngineGridLayoutCellSwizzle(L, UnityEngine.GridLayout.CellSwizzle.ZYX);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.GridLayout.CellSwizzle!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.GridLayout.CellSwizzle! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEnginePointerTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.PointerType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.PointerType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.PointerType), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mouse", UnityEngine.PointerType.Mouse);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Touch", UnityEngine.PointerType.Touch);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pen", UnityEngine.PointerType.Pen);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.PointerType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEnginePointerType(L, (UnityEngine.PointerType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Mouse"))
                {
                    translator.PushUnityEnginePointerType(L, UnityEngine.PointerType.Mouse);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Touch"))
                {
                    translator.PushUnityEnginePointerType(L, UnityEngine.PointerType.Touch);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Pen"))
                {
                    translator.PushUnityEnginePointerType(L, UnityEngine.PointerType.Pen);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.PointerType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.PointerType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineScaleModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ScaleMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ScaleMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ScaleMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StretchToFill", UnityEngine.ScaleMode.StretchToFill);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ScaleAndCrop", UnityEngine.ScaleMode.ScaleAndCrop);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ScaleToFit", UnityEngine.ScaleMode.ScaleToFit);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ScaleMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineScaleMode(L, (UnityEngine.ScaleMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "StretchToFill"))
                {
                    translator.PushUnityEngineScaleMode(L, UnityEngine.ScaleMode.StretchToFill);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ScaleAndCrop"))
                {
                    translator.PushUnityEngineScaleMode(L, UnityEngine.ScaleMode.ScaleAndCrop);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ScaleToFit"))
                {
                    translator.PushUnityEngineScaleMode(L, UnityEngine.ScaleMode.ScaleToFit);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ScaleMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ScaleMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineFocusTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.FocusType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.FocusType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.FocusType), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Keyboard", UnityEngine.FocusType.Keyboard);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Passive", UnityEngine.FocusType.Passive);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.FocusType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineFocusType(L, (UnityEngine.FocusType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Keyboard"))
                {
                    translator.PushUnityEngineFocusType(L, UnityEngine.FocusType.Keyboard);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Passive"))
                {
                    translator.PushUnityEngineFocusType(L, UnityEngine.FocusType.Passive);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.FocusType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.FocusType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineImagePositionWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ImagePosition), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ImagePosition), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ImagePosition), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ImageLeft", UnityEngine.ImagePosition.ImageLeft);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ImageAbove", UnityEngine.ImagePosition.ImageAbove);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ImageOnly", UnityEngine.ImagePosition.ImageOnly);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TextOnly", UnityEngine.ImagePosition.TextOnly);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ImagePosition), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineImagePosition(L, (UnityEngine.ImagePosition)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "ImageLeft"))
                {
                    translator.PushUnityEngineImagePosition(L, UnityEngine.ImagePosition.ImageLeft);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ImageAbove"))
                {
                    translator.PushUnityEngineImagePosition(L, UnityEngine.ImagePosition.ImageAbove);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ImageOnly"))
                {
                    translator.PushUnityEngineImagePosition(L, UnityEngine.ImagePosition.ImageOnly);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TextOnly"))
                {
                    translator.PushUnityEngineImagePosition(L, UnityEngine.ImagePosition.TextOnly);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ImagePosition!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ImagePosition! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineTouchPhaseWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.TouchPhase), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.TouchPhase), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.TouchPhase), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Began", UnityEngine.TouchPhase.Began);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Moved", UnityEngine.TouchPhase.Moved);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Stationary", UnityEngine.TouchPhase.Stationary);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Ended", UnityEngine.TouchPhase.Ended);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Canceled", UnityEngine.TouchPhase.Canceled);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.TouchPhase), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineTouchPhase(L, (UnityEngine.TouchPhase)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Began"))
                {
                    translator.PushUnityEngineTouchPhase(L, UnityEngine.TouchPhase.Began);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Moved"))
                {
                    translator.PushUnityEngineTouchPhase(L, UnityEngine.TouchPhase.Moved);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Stationary"))
                {
                    translator.PushUnityEngineTouchPhase(L, UnityEngine.TouchPhase.Stationary);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Ended"))
                {
                    translator.PushUnityEngineTouchPhase(L, UnityEngine.TouchPhase.Ended);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Canceled"))
                {
                    translator.PushUnityEngineTouchPhase(L, UnityEngine.TouchPhase.Canceled);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.TouchPhase!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.TouchPhase! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineIMECompositionModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.IMECompositionMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.IMECompositionMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.IMECompositionMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Auto", UnityEngine.IMECompositionMode.Auto);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "On", UnityEngine.IMECompositionMode.On);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Off", UnityEngine.IMECompositionMode.Off);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.IMECompositionMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineIMECompositionMode(L, (UnityEngine.IMECompositionMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Auto"))
                {
                    translator.PushUnityEngineIMECompositionMode(L, UnityEngine.IMECompositionMode.Auto);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "On"))
                {
                    translator.PushUnityEngineIMECompositionMode(L, UnityEngine.IMECompositionMode.On);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Off"))
                {
                    translator.PushUnityEngineIMECompositionMode(L, UnityEngine.IMECompositionMode.Off);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.IMECompositionMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.IMECompositionMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineTouchTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.TouchType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.TouchType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.TouchType), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Direct", UnityEngine.TouchType.Direct);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Indirect", UnityEngine.TouchType.Indirect);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Stylus", UnityEngine.TouchType.Stylus);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.TouchType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineTouchType(L, (UnityEngine.TouchType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Direct"))
                {
                    translator.PushUnityEngineTouchType(L, UnityEngine.TouchType.Direct);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Indirect"))
                {
                    translator.PushUnityEngineTouchType(L, UnityEngine.TouchType.Indirect);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Stylus"))
                {
                    translator.PushUnityEngineTouchType(L, UnityEngine.TouchType.Stylus);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.TouchType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.TouchType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineDeviceOrientationWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.DeviceOrientation), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.DeviceOrientation), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.DeviceOrientation), L, null, 8, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Unknown", UnityEngine.DeviceOrientation.Unknown);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Portrait", UnityEngine.DeviceOrientation.Portrait);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PortraitUpsideDown", UnityEngine.DeviceOrientation.PortraitUpsideDown);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LandscapeLeft", UnityEngine.DeviceOrientation.LandscapeLeft);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LandscapeRight", UnityEngine.DeviceOrientation.LandscapeRight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FaceUp", UnityEngine.DeviceOrientation.FaceUp);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FaceDown", UnityEngine.DeviceOrientation.FaceDown);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.DeviceOrientation), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineDeviceOrientation(L, (UnityEngine.DeviceOrientation)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Unknown"))
                {
                    translator.PushUnityEngineDeviceOrientation(L, UnityEngine.DeviceOrientation.Unknown);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Portrait"))
                {
                    translator.PushUnityEngineDeviceOrientation(L, UnityEngine.DeviceOrientation.Portrait);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PortraitUpsideDown"))
                {
                    translator.PushUnityEngineDeviceOrientation(L, UnityEngine.DeviceOrientation.PortraitUpsideDown);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LandscapeLeft"))
                {
                    translator.PushUnityEngineDeviceOrientation(L, UnityEngine.DeviceOrientation.LandscapeLeft);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LandscapeRight"))
                {
                    translator.PushUnityEngineDeviceOrientation(L, UnityEngine.DeviceOrientation.LandscapeRight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FaceUp"))
                {
                    translator.PushUnityEngineDeviceOrientation(L, UnityEngine.DeviceOrientation.FaceUp);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FaceDown"))
                {
                    translator.PushUnityEngineDeviceOrientation(L, UnityEngine.DeviceOrientation.FaceDown);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.DeviceOrientation!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.DeviceOrientation! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineLocationServiceStatusWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.LocationServiceStatus), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.LocationServiceStatus), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.LocationServiceStatus), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Stopped", UnityEngine.LocationServiceStatus.Stopped);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Initializing", UnityEngine.LocationServiceStatus.Initializing);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Running", UnityEngine.LocationServiceStatus.Running);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Failed", UnityEngine.LocationServiceStatus.Failed);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.LocationServiceStatus), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineLocationServiceStatus(L, (UnityEngine.LocationServiceStatus)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Stopped"))
                {
                    translator.PushUnityEngineLocationServiceStatus(L, UnityEngine.LocationServiceStatus.Stopped);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Initializing"))
                {
                    translator.PushUnityEngineLocationServiceStatus(L, UnityEngine.LocationServiceStatus.Initializing);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Running"))
                {
                    translator.PushUnityEngineLocationServiceStatus(L, UnityEngine.LocationServiceStatus.Running);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Failed"))
                {
                    translator.PushUnityEngineLocationServiceStatus(L, UnityEngine.LocationServiceStatus.Failed);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.LocationServiceStatus!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.LocationServiceStatus! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemRenderModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemRenderMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemRenderMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemRenderMode), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Billboard", UnityEngine.ParticleSystemRenderMode.Billboard);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Stretch", UnityEngine.ParticleSystemRenderMode.Stretch);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HorizontalBillboard", UnityEngine.ParticleSystemRenderMode.HorizontalBillboard);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VerticalBillboard", UnityEngine.ParticleSystemRenderMode.VerticalBillboard);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mesh", UnityEngine.ParticleSystemRenderMode.Mesh);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.ParticleSystemRenderMode.None);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemRenderMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemRenderMode(L, (UnityEngine.ParticleSystemRenderMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Billboard"))
                {
                    translator.PushUnityEngineParticleSystemRenderMode(L, UnityEngine.ParticleSystemRenderMode.Billboard);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Stretch"))
                {
                    translator.PushUnityEngineParticleSystemRenderMode(L, UnityEngine.ParticleSystemRenderMode.Stretch);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "HorizontalBillboard"))
                {
                    translator.PushUnityEngineParticleSystemRenderMode(L, UnityEngine.ParticleSystemRenderMode.HorizontalBillboard);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "VerticalBillboard"))
                {
                    translator.PushUnityEngineParticleSystemRenderMode(L, UnityEngine.ParticleSystemRenderMode.VerticalBillboard);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Mesh"))
                {
                    translator.PushUnityEngineParticleSystemRenderMode(L, UnityEngine.ParticleSystemRenderMode.Mesh);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineParticleSystemRenderMode(L, UnityEngine.ParticleSystemRenderMode.None);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemRenderMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemRenderMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemSortModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemSortMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemSortMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemSortMode), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.ParticleSystemSortMode.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Distance", UnityEngine.ParticleSystemSortMode.Distance);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OldestInFront", UnityEngine.ParticleSystemSortMode.OldestInFront);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "YoungestInFront", UnityEngine.ParticleSystemSortMode.YoungestInFront);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Depth", UnityEngine.ParticleSystemSortMode.Depth);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemSortMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemSortMode(L, (UnityEngine.ParticleSystemSortMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineParticleSystemSortMode(L, UnityEngine.ParticleSystemSortMode.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Distance"))
                {
                    translator.PushUnityEngineParticleSystemSortMode(L, UnityEngine.ParticleSystemSortMode.Distance);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "OldestInFront"))
                {
                    translator.PushUnityEngineParticleSystemSortMode(L, UnityEngine.ParticleSystemSortMode.OldestInFront);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "YoungestInFront"))
                {
                    translator.PushUnityEngineParticleSystemSortMode(L, UnityEngine.ParticleSystemSortMode.YoungestInFront);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Depth"))
                {
                    translator.PushUnityEngineParticleSystemSortMode(L, UnityEngine.ParticleSystemSortMode.Depth);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemSortMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemSortMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemCollisionQualityWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemCollisionQuality), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemCollisionQuality), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemCollisionQuality), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "High", UnityEngine.ParticleSystemCollisionQuality.High);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Medium", UnityEngine.ParticleSystemCollisionQuality.Medium);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Low", UnityEngine.ParticleSystemCollisionQuality.Low);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemCollisionQuality), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemCollisionQuality(L, (UnityEngine.ParticleSystemCollisionQuality)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "High"))
                {
                    translator.PushUnityEngineParticleSystemCollisionQuality(L, UnityEngine.ParticleSystemCollisionQuality.High);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Medium"))
                {
                    translator.PushUnityEngineParticleSystemCollisionQuality(L, UnityEngine.ParticleSystemCollisionQuality.Medium);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Low"))
                {
                    translator.PushUnityEngineParticleSystemCollisionQuality(L, UnityEngine.ParticleSystemCollisionQuality.Low);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemCollisionQuality!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemCollisionQuality! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemRenderSpaceWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemRenderSpace), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemRenderSpace), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemRenderSpace), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "View", UnityEngine.ParticleSystemRenderSpace.View);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "World", UnityEngine.ParticleSystemRenderSpace.World);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Local", UnityEngine.ParticleSystemRenderSpace.Local);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Facing", UnityEngine.ParticleSystemRenderSpace.Facing);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Velocity", UnityEngine.ParticleSystemRenderSpace.Velocity);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemRenderSpace), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemRenderSpace(L, (UnityEngine.ParticleSystemRenderSpace)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "View"))
                {
                    translator.PushUnityEngineParticleSystemRenderSpace(L, UnityEngine.ParticleSystemRenderSpace.View);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "World"))
                {
                    translator.PushUnityEngineParticleSystemRenderSpace(L, UnityEngine.ParticleSystemRenderSpace.World);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Local"))
                {
                    translator.PushUnityEngineParticleSystemRenderSpace(L, UnityEngine.ParticleSystemRenderSpace.Local);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Facing"))
                {
                    translator.PushUnityEngineParticleSystemRenderSpace(L, UnityEngine.ParticleSystemRenderSpace.Facing);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Velocity"))
                {
                    translator.PushUnityEngineParticleSystemRenderSpace(L, UnityEngine.ParticleSystemRenderSpace.Velocity);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemRenderSpace!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemRenderSpace! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemCurveModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemCurveMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemCurveMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemCurveMode), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Constant", UnityEngine.ParticleSystemCurveMode.Constant);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Curve", UnityEngine.ParticleSystemCurveMode.Curve);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TwoCurves", UnityEngine.ParticleSystemCurveMode.TwoCurves);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TwoConstants", UnityEngine.ParticleSystemCurveMode.TwoConstants);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemCurveMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemCurveMode(L, (UnityEngine.ParticleSystemCurveMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Constant"))
                {
                    translator.PushUnityEngineParticleSystemCurveMode(L, UnityEngine.ParticleSystemCurveMode.Constant);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Curve"))
                {
                    translator.PushUnityEngineParticleSystemCurveMode(L, UnityEngine.ParticleSystemCurveMode.Curve);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TwoCurves"))
                {
                    translator.PushUnityEngineParticleSystemCurveMode(L, UnityEngine.ParticleSystemCurveMode.TwoCurves);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TwoConstants"))
                {
                    translator.PushUnityEngineParticleSystemCurveMode(L, UnityEngine.ParticleSystemCurveMode.TwoConstants);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemCurveMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemCurveMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemGradientModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemGradientMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemGradientMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemGradientMode), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Color", UnityEngine.ParticleSystemGradientMode.Color);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Gradient", UnityEngine.ParticleSystemGradientMode.Gradient);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TwoColors", UnityEngine.ParticleSystemGradientMode.TwoColors);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TwoGradients", UnityEngine.ParticleSystemGradientMode.TwoGradients);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RandomColor", UnityEngine.ParticleSystemGradientMode.RandomColor);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemGradientMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemGradientMode(L, (UnityEngine.ParticleSystemGradientMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Color"))
                {
                    translator.PushUnityEngineParticleSystemGradientMode(L, UnityEngine.ParticleSystemGradientMode.Color);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Gradient"))
                {
                    translator.PushUnityEngineParticleSystemGradientMode(L, UnityEngine.ParticleSystemGradientMode.Gradient);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TwoColors"))
                {
                    translator.PushUnityEngineParticleSystemGradientMode(L, UnityEngine.ParticleSystemGradientMode.TwoColors);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TwoGradients"))
                {
                    translator.PushUnityEngineParticleSystemGradientMode(L, UnityEngine.ParticleSystemGradientMode.TwoGradients);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RandomColor"))
                {
                    translator.PushUnityEngineParticleSystemGradientMode(L, UnityEngine.ParticleSystemGradientMode.RandomColor);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemGradientMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemGradientMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemShapeTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemShapeType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemShapeType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemShapeType), L, null, 22, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Sphere", UnityEngine.ParticleSystemShapeType.Sphere);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Hemisphere", UnityEngine.ParticleSystemShapeType.Hemisphere);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Cone", UnityEngine.ParticleSystemShapeType.Cone);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Box", UnityEngine.ParticleSystemShapeType.Box);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mesh", UnityEngine.ParticleSystemShapeType.Mesh);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ConeVolume", UnityEngine.ParticleSystemShapeType.ConeVolume);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Circle", UnityEngine.ParticleSystemShapeType.Circle);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SingleSidedEdge", UnityEngine.ParticleSystemShapeType.SingleSidedEdge);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MeshRenderer", UnityEngine.ParticleSystemShapeType.MeshRenderer);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkinnedMeshRenderer", UnityEngine.ParticleSystemShapeType.SkinnedMeshRenderer);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BoxShell", UnityEngine.ParticleSystemShapeType.BoxShell);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BoxEdge", UnityEngine.ParticleSystemShapeType.BoxEdge);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Donut", UnityEngine.ParticleSystemShapeType.Donut);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Rectangle", UnityEngine.ParticleSystemShapeType.Rectangle);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Sprite", UnityEngine.ParticleSystemShapeType.Sprite);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SpriteRenderer", UnityEngine.ParticleSystemShapeType.SpriteRenderer);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemShapeType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemShapeType(L, (UnityEngine.ParticleSystemShapeType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Sphere"))
                {
                    translator.PushUnityEngineParticleSystemShapeType(L, UnityEngine.ParticleSystemShapeType.Sphere);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Hemisphere"))
                {
                    translator.PushUnityEngineParticleSystemShapeType(L, UnityEngine.ParticleSystemShapeType.Hemisphere);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Cone"))
                {
                    translator.PushUnityEngineParticleSystemShapeType(L, UnityEngine.ParticleSystemShapeType.Cone);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Box"))
                {
                    translator.PushUnityEngineParticleSystemShapeType(L, UnityEngine.ParticleSystemShapeType.Box);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Mesh"))
                {
                    translator.PushUnityEngineParticleSystemShapeType(L, UnityEngine.ParticleSystemShapeType.Mesh);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ConeVolume"))
                {
                    translator.PushUnityEngineParticleSystemShapeType(L, UnityEngine.ParticleSystemShapeType.ConeVolume);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Circle"))
                {
                    translator.PushUnityEngineParticleSystemShapeType(L, UnityEngine.ParticleSystemShapeType.Circle);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SingleSidedEdge"))
                {
                    translator.PushUnityEngineParticleSystemShapeType(L, UnityEngine.ParticleSystemShapeType.SingleSidedEdge);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MeshRenderer"))
                {
                    translator.PushUnityEngineParticleSystemShapeType(L, UnityEngine.ParticleSystemShapeType.MeshRenderer);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SkinnedMeshRenderer"))
                {
                    translator.PushUnityEngineParticleSystemShapeType(L, UnityEngine.ParticleSystemShapeType.SkinnedMeshRenderer);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BoxShell"))
                {
                    translator.PushUnityEngineParticleSystemShapeType(L, UnityEngine.ParticleSystemShapeType.BoxShell);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BoxEdge"))
                {
                    translator.PushUnityEngineParticleSystemShapeType(L, UnityEngine.ParticleSystemShapeType.BoxEdge);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Donut"))
                {
                    translator.PushUnityEngineParticleSystemShapeType(L, UnityEngine.ParticleSystemShapeType.Donut);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Rectangle"))
                {
                    translator.PushUnityEngineParticleSystemShapeType(L, UnityEngine.ParticleSystemShapeType.Rectangle);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Sprite"))
                {
                    translator.PushUnityEngineParticleSystemShapeType(L, UnityEngine.ParticleSystemShapeType.Sprite);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SpriteRenderer"))
                {
                    translator.PushUnityEngineParticleSystemShapeType(L, UnityEngine.ParticleSystemShapeType.SpriteRenderer);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemShapeType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemShapeType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemMeshShapeTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemMeshShapeType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemMeshShapeType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemMeshShapeType), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vertex", UnityEngine.ParticleSystemMeshShapeType.Vertex);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Edge", UnityEngine.ParticleSystemMeshShapeType.Edge);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Triangle", UnityEngine.ParticleSystemMeshShapeType.Triangle);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemMeshShapeType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemMeshShapeType(L, (UnityEngine.ParticleSystemMeshShapeType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Vertex"))
                {
                    translator.PushUnityEngineParticleSystemMeshShapeType(L, UnityEngine.ParticleSystemMeshShapeType.Vertex);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Edge"))
                {
                    translator.PushUnityEngineParticleSystemMeshShapeType(L, UnityEngine.ParticleSystemMeshShapeType.Edge);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Triangle"))
                {
                    translator.PushUnityEngineParticleSystemMeshShapeType(L, UnityEngine.ParticleSystemMeshShapeType.Triangle);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemMeshShapeType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemMeshShapeType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemShapeTextureChannelWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemShapeTextureChannel), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemShapeTextureChannel), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemShapeTextureChannel), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Red", UnityEngine.ParticleSystemShapeTextureChannel.Red);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Green", UnityEngine.ParticleSystemShapeTextureChannel.Green);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Blue", UnityEngine.ParticleSystemShapeTextureChannel.Blue);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Alpha", UnityEngine.ParticleSystemShapeTextureChannel.Alpha);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemShapeTextureChannel), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemShapeTextureChannel(L, (UnityEngine.ParticleSystemShapeTextureChannel)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Red"))
                {
                    translator.PushUnityEngineParticleSystemShapeTextureChannel(L, UnityEngine.ParticleSystemShapeTextureChannel.Red);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Green"))
                {
                    translator.PushUnityEngineParticleSystemShapeTextureChannel(L, UnityEngine.ParticleSystemShapeTextureChannel.Green);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Blue"))
                {
                    translator.PushUnityEngineParticleSystemShapeTextureChannel(L, UnityEngine.ParticleSystemShapeTextureChannel.Blue);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Alpha"))
                {
                    translator.PushUnityEngineParticleSystemShapeTextureChannel(L, UnityEngine.ParticleSystemShapeTextureChannel.Alpha);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemShapeTextureChannel!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemShapeTextureChannel! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemAnimationModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemAnimationMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemAnimationMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemAnimationMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Grid", UnityEngine.ParticleSystemAnimationMode.Grid);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Sprites", UnityEngine.ParticleSystemAnimationMode.Sprites);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemAnimationMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemAnimationMode(L, (UnityEngine.ParticleSystemAnimationMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Grid"))
                {
                    translator.PushUnityEngineParticleSystemAnimationMode(L, UnityEngine.ParticleSystemAnimationMode.Grid);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Sprites"))
                {
                    translator.PushUnityEngineParticleSystemAnimationMode(L, UnityEngine.ParticleSystemAnimationMode.Sprites);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemAnimationMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemAnimationMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemAnimationTimeModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemAnimationTimeMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemAnimationTimeMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemAnimationTimeMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Lifetime", UnityEngine.ParticleSystemAnimationTimeMode.Lifetime);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Speed", UnityEngine.ParticleSystemAnimationTimeMode.Speed);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FPS", UnityEngine.ParticleSystemAnimationTimeMode.FPS);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemAnimationTimeMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemAnimationTimeMode(L, (UnityEngine.ParticleSystemAnimationTimeMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Lifetime"))
                {
                    translator.PushUnityEngineParticleSystemAnimationTimeMode(L, UnityEngine.ParticleSystemAnimationTimeMode.Lifetime);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Speed"))
                {
                    translator.PushUnityEngineParticleSystemAnimationTimeMode(L, UnityEngine.ParticleSystemAnimationTimeMode.Speed);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FPS"))
                {
                    translator.PushUnityEngineParticleSystemAnimationTimeMode(L, UnityEngine.ParticleSystemAnimationTimeMode.FPS);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemAnimationTimeMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemAnimationTimeMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemAnimationTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemAnimationType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemAnimationType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemAnimationType), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WholeSheet", UnityEngine.ParticleSystemAnimationType.WholeSheet);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SingleRow", UnityEngine.ParticleSystemAnimationType.SingleRow);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemAnimationType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemAnimationType(L, (UnityEngine.ParticleSystemAnimationType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "WholeSheet"))
                {
                    translator.PushUnityEngineParticleSystemAnimationType(L, UnityEngine.ParticleSystemAnimationType.WholeSheet);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SingleRow"))
                {
                    translator.PushUnityEngineParticleSystemAnimationType(L, UnityEngine.ParticleSystemAnimationType.SingleRow);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemAnimationType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemAnimationType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemAnimationRowModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemAnimationRowMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemAnimationRowMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemAnimationRowMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Custom", UnityEngine.ParticleSystemAnimationRowMode.Custom);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Random", UnityEngine.ParticleSystemAnimationRowMode.Random);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MeshIndex", UnityEngine.ParticleSystemAnimationRowMode.MeshIndex);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemAnimationRowMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemAnimationRowMode(L, (UnityEngine.ParticleSystemAnimationRowMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Custom"))
                {
                    translator.PushUnityEngineParticleSystemAnimationRowMode(L, UnityEngine.ParticleSystemAnimationRowMode.Custom);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Random"))
                {
                    translator.PushUnityEngineParticleSystemAnimationRowMode(L, UnityEngine.ParticleSystemAnimationRowMode.Random);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MeshIndex"))
                {
                    translator.PushUnityEngineParticleSystemAnimationRowMode(L, UnityEngine.ParticleSystemAnimationRowMode.MeshIndex);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemAnimationRowMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemAnimationRowMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemCollisionTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemCollisionType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemCollisionType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemCollisionType), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Planes", UnityEngine.ParticleSystemCollisionType.Planes);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "World", UnityEngine.ParticleSystemCollisionType.World);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemCollisionType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemCollisionType(L, (UnityEngine.ParticleSystemCollisionType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Planes"))
                {
                    translator.PushUnityEngineParticleSystemCollisionType(L, UnityEngine.ParticleSystemCollisionType.Planes);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "World"))
                {
                    translator.PushUnityEngineParticleSystemCollisionType(L, UnityEngine.ParticleSystemCollisionType.World);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemCollisionType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemCollisionType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemCollisionModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemCollisionMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemCollisionMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemCollisionMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Collision3D", UnityEngine.ParticleSystemCollisionMode.Collision3D);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Collision2D", UnityEngine.ParticleSystemCollisionMode.Collision2D);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemCollisionMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemCollisionMode(L, (UnityEngine.ParticleSystemCollisionMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Collision3D"))
                {
                    translator.PushUnityEngineParticleSystemCollisionMode(L, UnityEngine.ParticleSystemCollisionMode.Collision3D);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Collision2D"))
                {
                    translator.PushUnityEngineParticleSystemCollisionMode(L, UnityEngine.ParticleSystemCollisionMode.Collision2D);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemCollisionMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemCollisionMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemOverlapActionWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemOverlapAction), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemOverlapAction), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemOverlapAction), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Ignore", UnityEngine.ParticleSystemOverlapAction.Ignore);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Kill", UnityEngine.ParticleSystemOverlapAction.Kill);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Callback", UnityEngine.ParticleSystemOverlapAction.Callback);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemOverlapAction), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemOverlapAction(L, (UnityEngine.ParticleSystemOverlapAction)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Ignore"))
                {
                    translator.PushUnityEngineParticleSystemOverlapAction(L, UnityEngine.ParticleSystemOverlapAction.Ignore);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Kill"))
                {
                    translator.PushUnityEngineParticleSystemOverlapAction(L, UnityEngine.ParticleSystemOverlapAction.Kill);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Callback"))
                {
                    translator.PushUnityEngineParticleSystemOverlapAction(L, UnityEngine.ParticleSystemOverlapAction.Callback);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemOverlapAction!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemOverlapAction! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemColliderQueryModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemColliderQueryMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemColliderQueryMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemColliderQueryMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Disabled", UnityEngine.ParticleSystemColliderQueryMode.Disabled);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "One", UnityEngine.ParticleSystemColliderQueryMode.One);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "All", UnityEngine.ParticleSystemColliderQueryMode.All);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemColliderQueryMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemColliderQueryMode(L, (UnityEngine.ParticleSystemColliderQueryMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Disabled"))
                {
                    translator.PushUnityEngineParticleSystemColliderQueryMode(L, UnityEngine.ParticleSystemColliderQueryMode.Disabled);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "One"))
                {
                    translator.PushUnityEngineParticleSystemColliderQueryMode(L, UnityEngine.ParticleSystemColliderQueryMode.One);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "All"))
                {
                    translator.PushUnityEngineParticleSystemColliderQueryMode(L, UnityEngine.ParticleSystemColliderQueryMode.All);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemColliderQueryMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemColliderQueryMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemSimulationSpaceWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemSimulationSpace), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemSimulationSpace), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemSimulationSpace), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Local", UnityEngine.ParticleSystemSimulationSpace.Local);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "World", UnityEngine.ParticleSystemSimulationSpace.World);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Custom", UnityEngine.ParticleSystemSimulationSpace.Custom);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemSimulationSpace), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemSimulationSpace(L, (UnityEngine.ParticleSystemSimulationSpace)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Local"))
                {
                    translator.PushUnityEngineParticleSystemSimulationSpace(L, UnityEngine.ParticleSystemSimulationSpace.Local);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "World"))
                {
                    translator.PushUnityEngineParticleSystemSimulationSpace(L, UnityEngine.ParticleSystemSimulationSpace.World);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Custom"))
                {
                    translator.PushUnityEngineParticleSystemSimulationSpace(L, UnityEngine.ParticleSystemSimulationSpace.Custom);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemSimulationSpace!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemSimulationSpace! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemStopBehaviorWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemStopBehavior), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemStopBehavior), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemStopBehavior), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StopEmittingAndClear", UnityEngine.ParticleSystemStopBehavior.StopEmittingAndClear);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StopEmitting", UnityEngine.ParticleSystemStopBehavior.StopEmitting);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemStopBehavior), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemStopBehavior(L, (UnityEngine.ParticleSystemStopBehavior)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "StopEmittingAndClear"))
                {
                    translator.PushUnityEngineParticleSystemStopBehavior(L, UnityEngine.ParticleSystemStopBehavior.StopEmittingAndClear);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "StopEmitting"))
                {
                    translator.PushUnityEngineParticleSystemStopBehavior(L, UnityEngine.ParticleSystemStopBehavior.StopEmitting);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemStopBehavior!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemStopBehavior! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemScalingModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemScalingMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemScalingMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemScalingMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Hierarchy", UnityEngine.ParticleSystemScalingMode.Hierarchy);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Local", UnityEngine.ParticleSystemScalingMode.Local);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Shape", UnityEngine.ParticleSystemScalingMode.Shape);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemScalingMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemScalingMode(L, (UnityEngine.ParticleSystemScalingMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Hierarchy"))
                {
                    translator.PushUnityEngineParticleSystemScalingMode(L, UnityEngine.ParticleSystemScalingMode.Hierarchy);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Local"))
                {
                    translator.PushUnityEngineParticleSystemScalingMode(L, UnityEngine.ParticleSystemScalingMode.Local);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Shape"))
                {
                    translator.PushUnityEngineParticleSystemScalingMode(L, UnityEngine.ParticleSystemScalingMode.Shape);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemScalingMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemScalingMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemStopActionWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemStopAction), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemStopAction), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemStopAction), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.ParticleSystemStopAction.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Disable", UnityEngine.ParticleSystemStopAction.Disable);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Destroy", UnityEngine.ParticleSystemStopAction.Destroy);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Callback", UnityEngine.ParticleSystemStopAction.Callback);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemStopAction), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemStopAction(L, (UnityEngine.ParticleSystemStopAction)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineParticleSystemStopAction(L, UnityEngine.ParticleSystemStopAction.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Disable"))
                {
                    translator.PushUnityEngineParticleSystemStopAction(L, UnityEngine.ParticleSystemStopAction.Disable);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Destroy"))
                {
                    translator.PushUnityEngineParticleSystemStopAction(L, UnityEngine.ParticleSystemStopAction.Destroy);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Callback"))
                {
                    translator.PushUnityEngineParticleSystemStopAction(L, UnityEngine.ParticleSystemStopAction.Callback);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemStopAction!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemStopAction! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemCullingModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemCullingMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemCullingMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemCullingMode), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Automatic", UnityEngine.ParticleSystemCullingMode.Automatic);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PauseAndCatchup", UnityEngine.ParticleSystemCullingMode.PauseAndCatchup);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pause", UnityEngine.ParticleSystemCullingMode.Pause);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AlwaysSimulate", UnityEngine.ParticleSystemCullingMode.AlwaysSimulate);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemCullingMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemCullingMode(L, (UnityEngine.ParticleSystemCullingMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Automatic"))
                {
                    translator.PushUnityEngineParticleSystemCullingMode(L, UnityEngine.ParticleSystemCullingMode.Automatic);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PauseAndCatchup"))
                {
                    translator.PushUnityEngineParticleSystemCullingMode(L, UnityEngine.ParticleSystemCullingMode.PauseAndCatchup);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Pause"))
                {
                    translator.PushUnityEngineParticleSystemCullingMode(L, UnityEngine.ParticleSystemCullingMode.Pause);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AlwaysSimulate"))
                {
                    translator.PushUnityEngineParticleSystemCullingMode(L, UnityEngine.ParticleSystemCullingMode.AlwaysSimulate);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemCullingMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemCullingMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemEmitterVelocityModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemEmitterVelocityMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemEmitterVelocityMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemEmitterVelocityMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Transform", UnityEngine.ParticleSystemEmitterVelocityMode.Transform);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Rigidbody", UnityEngine.ParticleSystemEmitterVelocityMode.Rigidbody);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemEmitterVelocityMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemEmitterVelocityMode(L, (UnityEngine.ParticleSystemEmitterVelocityMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Transform"))
                {
                    translator.PushUnityEngineParticleSystemEmitterVelocityMode(L, UnityEngine.ParticleSystemEmitterVelocityMode.Transform);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Rigidbody"))
                {
                    translator.PushUnityEngineParticleSystemEmitterVelocityMode(L, UnityEngine.ParticleSystemEmitterVelocityMode.Rigidbody);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemEmitterVelocityMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemEmitterVelocityMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemInheritVelocityModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemInheritVelocityMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemInheritVelocityMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemInheritVelocityMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Initial", UnityEngine.ParticleSystemInheritVelocityMode.Initial);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Current", UnityEngine.ParticleSystemInheritVelocityMode.Current);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemInheritVelocityMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemInheritVelocityMode(L, (UnityEngine.ParticleSystemInheritVelocityMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Initial"))
                {
                    translator.PushUnityEngineParticleSystemInheritVelocityMode(L, UnityEngine.ParticleSystemInheritVelocityMode.Initial);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Current"))
                {
                    translator.PushUnityEngineParticleSystemInheritVelocityMode(L, UnityEngine.ParticleSystemInheritVelocityMode.Current);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemInheritVelocityMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemInheritVelocityMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemVertexStreamWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemVertexStream), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemVertexStream), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemVertexStream), L, null, 47, 0, 0);

            Utils.RegisterEnumType(L, typeof(UnityEngine.ParticleSystemVertexStream));

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemVertexStream), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemVertexStream(L, (UnityEngine.ParticleSystemVertexStream)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

                try
				{
                    translator.TranslateToEnumToTop(L, typeof(UnityEngine.ParticleSystemVertexStream), 1);
				}
				catch (System.Exception e)
				{
					return LuaAPI.luaL_error(L, "cast to " + typeof(UnityEngine.ParticleSystemVertexStream) + " exception:" + e);
				}

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemVertexStream! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemCustomDataWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemCustomData), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemCustomData), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemCustomData), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Custom1", UnityEngine.ParticleSystemCustomData.Custom1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Custom2", UnityEngine.ParticleSystemCustomData.Custom2);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemCustomData), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemCustomData(L, (UnityEngine.ParticleSystemCustomData)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Custom1"))
                {
                    translator.PushUnityEngineParticleSystemCustomData(L, UnityEngine.ParticleSystemCustomData.Custom1);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Custom2"))
                {
                    translator.PushUnityEngineParticleSystemCustomData(L, UnityEngine.ParticleSystemCustomData.Custom2);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemCustomData!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemCustomData! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemCustomDataModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemCustomDataMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemCustomDataMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemCustomDataMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Disabled", UnityEngine.ParticleSystemCustomDataMode.Disabled);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vector", UnityEngine.ParticleSystemCustomDataMode.Vector);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Color", UnityEngine.ParticleSystemCustomDataMode.Color);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemCustomDataMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemCustomDataMode(L, (UnityEngine.ParticleSystemCustomDataMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Disabled"))
                {
                    translator.PushUnityEngineParticleSystemCustomDataMode(L, UnityEngine.ParticleSystemCustomDataMode.Disabled);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Vector"))
                {
                    translator.PushUnityEngineParticleSystemCustomDataMode(L, UnityEngine.ParticleSystemCustomDataMode.Vector);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Color"))
                {
                    translator.PushUnityEngineParticleSystemCustomDataMode(L, UnityEngine.ParticleSystemCustomDataMode.Color);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemCustomDataMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemCustomDataMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemNoiseQualityWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemNoiseQuality), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemNoiseQuality), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemNoiseQuality), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Low", UnityEngine.ParticleSystemNoiseQuality.Low);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Medium", UnityEngine.ParticleSystemNoiseQuality.Medium);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "High", UnityEngine.ParticleSystemNoiseQuality.High);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemNoiseQuality), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemNoiseQuality(L, (UnityEngine.ParticleSystemNoiseQuality)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Low"))
                {
                    translator.PushUnityEngineParticleSystemNoiseQuality(L, UnityEngine.ParticleSystemNoiseQuality.Low);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Medium"))
                {
                    translator.PushUnityEngineParticleSystemNoiseQuality(L, UnityEngine.ParticleSystemNoiseQuality.Medium);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "High"))
                {
                    translator.PushUnityEngineParticleSystemNoiseQuality(L, UnityEngine.ParticleSystemNoiseQuality.High);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemNoiseQuality!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemNoiseQuality! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemSubEmitterTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemSubEmitterType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemSubEmitterType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemSubEmitterType), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Birth", UnityEngine.ParticleSystemSubEmitterType.Birth);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Collision", UnityEngine.ParticleSystemSubEmitterType.Collision);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Death", UnityEngine.ParticleSystemSubEmitterType.Death);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Trigger", UnityEngine.ParticleSystemSubEmitterType.Trigger);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Manual", UnityEngine.ParticleSystemSubEmitterType.Manual);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemSubEmitterType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemSubEmitterType(L, (UnityEngine.ParticleSystemSubEmitterType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Birth"))
                {
                    translator.PushUnityEngineParticleSystemSubEmitterType(L, UnityEngine.ParticleSystemSubEmitterType.Birth);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Collision"))
                {
                    translator.PushUnityEngineParticleSystemSubEmitterType(L, UnityEngine.ParticleSystemSubEmitterType.Collision);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Death"))
                {
                    translator.PushUnityEngineParticleSystemSubEmitterType(L, UnityEngine.ParticleSystemSubEmitterType.Death);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Trigger"))
                {
                    translator.PushUnityEngineParticleSystemSubEmitterType(L, UnityEngine.ParticleSystemSubEmitterType.Trigger);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Manual"))
                {
                    translator.PushUnityEngineParticleSystemSubEmitterType(L, UnityEngine.ParticleSystemSubEmitterType.Manual);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemSubEmitterType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemSubEmitterType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemSubEmitterPropertiesWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemSubEmitterProperties), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemSubEmitterProperties), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemSubEmitterProperties), L, null, 8, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "InheritNothing", UnityEngine.ParticleSystemSubEmitterProperties.InheritNothing);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "InheritEverything", UnityEngine.ParticleSystemSubEmitterProperties.InheritEverything);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "InheritColor", UnityEngine.ParticleSystemSubEmitterProperties.InheritColor);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "InheritSize", UnityEngine.ParticleSystemSubEmitterProperties.InheritSize);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "InheritRotation", UnityEngine.ParticleSystemSubEmitterProperties.InheritRotation);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "InheritLifetime", UnityEngine.ParticleSystemSubEmitterProperties.InheritLifetime);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "InheritDuration", UnityEngine.ParticleSystemSubEmitterProperties.InheritDuration);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemSubEmitterProperties), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemSubEmitterProperties(L, (UnityEngine.ParticleSystemSubEmitterProperties)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "InheritNothing"))
                {
                    translator.PushUnityEngineParticleSystemSubEmitterProperties(L, UnityEngine.ParticleSystemSubEmitterProperties.InheritNothing);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "InheritEverything"))
                {
                    translator.PushUnityEngineParticleSystemSubEmitterProperties(L, UnityEngine.ParticleSystemSubEmitterProperties.InheritEverything);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "InheritColor"))
                {
                    translator.PushUnityEngineParticleSystemSubEmitterProperties(L, UnityEngine.ParticleSystemSubEmitterProperties.InheritColor);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "InheritSize"))
                {
                    translator.PushUnityEngineParticleSystemSubEmitterProperties(L, UnityEngine.ParticleSystemSubEmitterProperties.InheritSize);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "InheritRotation"))
                {
                    translator.PushUnityEngineParticleSystemSubEmitterProperties(L, UnityEngine.ParticleSystemSubEmitterProperties.InheritRotation);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "InheritLifetime"))
                {
                    translator.PushUnityEngineParticleSystemSubEmitterProperties(L, UnityEngine.ParticleSystemSubEmitterProperties.InheritLifetime);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "InheritDuration"))
                {
                    translator.PushUnityEngineParticleSystemSubEmitterProperties(L, UnityEngine.ParticleSystemSubEmitterProperties.InheritDuration);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemSubEmitterProperties!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemSubEmitterProperties! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemTrailModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemTrailMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemTrailMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemTrailMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PerParticle", UnityEngine.ParticleSystemTrailMode.PerParticle);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Ribbon", UnityEngine.ParticleSystemTrailMode.Ribbon);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemTrailMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemTrailMode(L, (UnityEngine.ParticleSystemTrailMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "PerParticle"))
                {
                    translator.PushUnityEngineParticleSystemTrailMode(L, UnityEngine.ParticleSystemTrailMode.PerParticle);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Ribbon"))
                {
                    translator.PushUnityEngineParticleSystemTrailMode(L, UnityEngine.ParticleSystemTrailMode.Ribbon);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemTrailMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemTrailMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemTrailTextureModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemTrailTextureMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemTrailTextureMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemTrailTextureMode), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Stretch", UnityEngine.ParticleSystemTrailTextureMode.Stretch);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Tile", UnityEngine.ParticleSystemTrailTextureMode.Tile);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DistributePerSegment", UnityEngine.ParticleSystemTrailTextureMode.DistributePerSegment);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RepeatPerSegment", UnityEngine.ParticleSystemTrailTextureMode.RepeatPerSegment);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemTrailTextureMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemTrailTextureMode(L, (UnityEngine.ParticleSystemTrailTextureMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Stretch"))
                {
                    translator.PushUnityEngineParticleSystemTrailTextureMode(L, UnityEngine.ParticleSystemTrailTextureMode.Stretch);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Tile"))
                {
                    translator.PushUnityEngineParticleSystemTrailTextureMode(L, UnityEngine.ParticleSystemTrailTextureMode.Tile);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DistributePerSegment"))
                {
                    translator.PushUnityEngineParticleSystemTrailTextureMode(L, UnityEngine.ParticleSystemTrailTextureMode.DistributePerSegment);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RepeatPerSegment"))
                {
                    translator.PushUnityEngineParticleSystemTrailTextureMode(L, UnityEngine.ParticleSystemTrailTextureMode.RepeatPerSegment);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemTrailTextureMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemTrailTextureMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemShapeMultiModeValueWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemShapeMultiModeValue), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemShapeMultiModeValue), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemShapeMultiModeValue), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Random", UnityEngine.ParticleSystemShapeMultiModeValue.Random);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Loop", UnityEngine.ParticleSystemShapeMultiModeValue.Loop);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PingPong", UnityEngine.ParticleSystemShapeMultiModeValue.PingPong);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BurstSpread", UnityEngine.ParticleSystemShapeMultiModeValue.BurstSpread);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemShapeMultiModeValue), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemShapeMultiModeValue(L, (UnityEngine.ParticleSystemShapeMultiModeValue)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Random"))
                {
                    translator.PushUnityEngineParticleSystemShapeMultiModeValue(L, UnityEngine.ParticleSystemShapeMultiModeValue.Random);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Loop"))
                {
                    translator.PushUnityEngineParticleSystemShapeMultiModeValue(L, UnityEngine.ParticleSystemShapeMultiModeValue.Loop);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PingPong"))
                {
                    translator.PushUnityEngineParticleSystemShapeMultiModeValue(L, UnityEngine.ParticleSystemShapeMultiModeValue.PingPong);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BurstSpread"))
                {
                    translator.PushUnityEngineParticleSystemShapeMultiModeValue(L, UnityEngine.ParticleSystemShapeMultiModeValue.BurstSpread);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemShapeMultiModeValue!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemShapeMultiModeValue! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemRingBufferModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemRingBufferMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemRingBufferMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemRingBufferMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Disabled", UnityEngine.ParticleSystemRingBufferMode.Disabled);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PauseUntilReplaced", UnityEngine.ParticleSystemRingBufferMode.PauseUntilReplaced);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LoopUntilReplaced", UnityEngine.ParticleSystemRingBufferMode.LoopUntilReplaced);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemRingBufferMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemRingBufferMode(L, (UnityEngine.ParticleSystemRingBufferMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Disabled"))
                {
                    translator.PushUnityEngineParticleSystemRingBufferMode(L, UnityEngine.ParticleSystemRingBufferMode.Disabled);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PauseUntilReplaced"))
                {
                    translator.PushUnityEngineParticleSystemRingBufferMode(L, UnityEngine.ParticleSystemRingBufferMode.PauseUntilReplaced);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LoopUntilReplaced"))
                {
                    translator.PushUnityEngineParticleSystemRingBufferMode(L, UnityEngine.ParticleSystemRingBufferMode.LoopUntilReplaced);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemRingBufferMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemRingBufferMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemGameObjectFilterWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemGameObjectFilter), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemGameObjectFilter), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemGameObjectFilter), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LayerMask", UnityEngine.ParticleSystemGameObjectFilter.LayerMask);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "List", UnityEngine.ParticleSystemGameObjectFilter.List);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LayerMaskAndList", UnityEngine.ParticleSystemGameObjectFilter.LayerMaskAndList);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemGameObjectFilter), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemGameObjectFilter(L, (UnityEngine.ParticleSystemGameObjectFilter)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "LayerMask"))
                {
                    translator.PushUnityEngineParticleSystemGameObjectFilter(L, UnityEngine.ParticleSystemGameObjectFilter.LayerMask);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "List"))
                {
                    translator.PushUnityEngineParticleSystemGameObjectFilter(L, UnityEngine.ParticleSystemGameObjectFilter.List);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LayerMaskAndList"))
                {
                    translator.PushUnityEngineParticleSystemGameObjectFilter(L, UnityEngine.ParticleSystemGameObjectFilter.LayerMaskAndList);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemGameObjectFilter!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemGameObjectFilter! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineParticleSystemForceFieldShapeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ParticleSystemForceFieldShape), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ParticleSystemForceFieldShape), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ParticleSystemForceFieldShape), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Sphere", UnityEngine.ParticleSystemForceFieldShape.Sphere);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Hemisphere", UnityEngine.ParticleSystemForceFieldShape.Hemisphere);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Cylinder", UnityEngine.ParticleSystemForceFieldShape.Cylinder);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Box", UnityEngine.ParticleSystemForceFieldShape.Box);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ParticleSystemForceFieldShape), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineParticleSystemForceFieldShape(L, (UnityEngine.ParticleSystemForceFieldShape)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Sphere"))
                {
                    translator.PushUnityEngineParticleSystemForceFieldShape(L, UnityEngine.ParticleSystemForceFieldShape.Sphere);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Hemisphere"))
                {
                    translator.PushUnityEngineParticleSystemForceFieldShape(L, UnityEngine.ParticleSystemForceFieldShape.Hemisphere);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Cylinder"))
                {
                    translator.PushUnityEngineParticleSystemForceFieldShape(L, UnityEngine.ParticleSystemForceFieldShape.Cylinder);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Box"))
                {
                    translator.PushUnityEngineParticleSystemForceFieldShape(L, UnityEngine.ParticleSystemForceFieldShape.Box);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ParticleSystemForceFieldShape!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ParticleSystemForceFieldShape! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderingUVChannelFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.UVChannelFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Rendering.UVChannelFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Rendering.UVChannelFlags), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UV0", UnityEngine.Rendering.UVChannelFlags.UV0);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UV1", UnityEngine.Rendering.UVChannelFlags.UV1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UV2", UnityEngine.Rendering.UVChannelFlags.UV2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UV3", UnityEngine.Rendering.UVChannelFlags.UV3);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Rendering.UVChannelFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderingUVChannelFlags(L, (UnityEngine.Rendering.UVChannelFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "UV0"))
                {
                    translator.PushUnityEngineRenderingUVChannelFlags(L, UnityEngine.Rendering.UVChannelFlags.UV0);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UV1"))
                {
                    translator.PushUnityEngineRenderingUVChannelFlags(L, UnityEngine.Rendering.UVChannelFlags.UV1);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UV2"))
                {
                    translator.PushUnityEngineRenderingUVChannelFlags(L, UnityEngine.Rendering.UVChannelFlags.UV2);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UV3"))
                {
                    translator.PushUnityEngineRenderingUVChannelFlags(L, UnityEngine.Rendering.UVChannelFlags.UV3);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.UVChannelFlags!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.UVChannelFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineSimulationMode2DWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.SimulationMode2D), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.SimulationMode2D), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.SimulationMode2D), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FixedUpdate", UnityEngine.SimulationMode2D.FixedUpdate);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Update", UnityEngine.SimulationMode2D.Update);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Script", UnityEngine.SimulationMode2D.Script);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.SimulationMode2D), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineSimulationMode2D(L, (UnityEngine.SimulationMode2D)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "FixedUpdate"))
                {
                    translator.PushUnityEngineSimulationMode2D(L, UnityEngine.SimulationMode2D.FixedUpdate);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Update"))
                {
                    translator.PushUnityEngineSimulationMode2D(L, UnityEngine.SimulationMode2D.Update);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Script"))
                {
                    translator.PushUnityEngineSimulationMode2D(L, UnityEngine.SimulationMode2D.Script);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.SimulationMode2D!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.SimulationMode2D! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCapsuleDirection2DWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.CapsuleDirection2D), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.CapsuleDirection2D), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.CapsuleDirection2D), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vertical", UnityEngine.CapsuleDirection2D.Vertical);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Horizontal", UnityEngine.CapsuleDirection2D.Horizontal);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.CapsuleDirection2D), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCapsuleDirection2D(L, (UnityEngine.CapsuleDirection2D)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Vertical"))
                {
                    translator.PushUnityEngineCapsuleDirection2D(L, UnityEngine.CapsuleDirection2D.Vertical);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Horizontal"))
                {
                    translator.PushUnityEngineCapsuleDirection2D(L, UnityEngine.CapsuleDirection2D.Horizontal);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.CapsuleDirection2D!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.CapsuleDirection2D! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRigidbodyConstraints2DWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.RigidbodyConstraints2D), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.RigidbodyConstraints2D), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.RigidbodyConstraints2D), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.RigidbodyConstraints2D.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreezePositionX", UnityEngine.RigidbodyConstraints2D.FreezePositionX);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreezePositionY", UnityEngine.RigidbodyConstraints2D.FreezePositionY);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreezeRotation", UnityEngine.RigidbodyConstraints2D.FreezeRotation);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreezePosition", UnityEngine.RigidbodyConstraints2D.FreezePosition);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreezeAll", UnityEngine.RigidbodyConstraints2D.FreezeAll);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.RigidbodyConstraints2D), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRigidbodyConstraints2D(L, (UnityEngine.RigidbodyConstraints2D)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineRigidbodyConstraints2D(L, UnityEngine.RigidbodyConstraints2D.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FreezePositionX"))
                {
                    translator.PushUnityEngineRigidbodyConstraints2D(L, UnityEngine.RigidbodyConstraints2D.FreezePositionX);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FreezePositionY"))
                {
                    translator.PushUnityEngineRigidbodyConstraints2D(L, UnityEngine.RigidbodyConstraints2D.FreezePositionY);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FreezeRotation"))
                {
                    translator.PushUnityEngineRigidbodyConstraints2D(L, UnityEngine.RigidbodyConstraints2D.FreezeRotation);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FreezePosition"))
                {
                    translator.PushUnityEngineRigidbodyConstraints2D(L, UnityEngine.RigidbodyConstraints2D.FreezePosition);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FreezeAll"))
                {
                    translator.PushUnityEngineRigidbodyConstraints2D(L, UnityEngine.RigidbodyConstraints2D.FreezeAll);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.RigidbodyConstraints2D!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RigidbodyConstraints2D! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRigidbodyInterpolation2DWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.RigidbodyInterpolation2D), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.RigidbodyInterpolation2D), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.RigidbodyInterpolation2D), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.RigidbodyInterpolation2D.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Interpolate", UnityEngine.RigidbodyInterpolation2D.Interpolate);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Extrapolate", UnityEngine.RigidbodyInterpolation2D.Extrapolate);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.RigidbodyInterpolation2D), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRigidbodyInterpolation2D(L, (UnityEngine.RigidbodyInterpolation2D)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineRigidbodyInterpolation2D(L, UnityEngine.RigidbodyInterpolation2D.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Interpolate"))
                {
                    translator.PushUnityEngineRigidbodyInterpolation2D(L, UnityEngine.RigidbodyInterpolation2D.Interpolate);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Extrapolate"))
                {
                    translator.PushUnityEngineRigidbodyInterpolation2D(L, UnityEngine.RigidbodyInterpolation2D.Extrapolate);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.RigidbodyInterpolation2D!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RigidbodyInterpolation2D! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRigidbodySleepMode2DWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.RigidbodySleepMode2D), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.RigidbodySleepMode2D), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.RigidbodySleepMode2D), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NeverSleep", UnityEngine.RigidbodySleepMode2D.NeverSleep);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StartAwake", UnityEngine.RigidbodySleepMode2D.StartAwake);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StartAsleep", UnityEngine.RigidbodySleepMode2D.StartAsleep);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.RigidbodySleepMode2D), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRigidbodySleepMode2D(L, (UnityEngine.RigidbodySleepMode2D)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "NeverSleep"))
                {
                    translator.PushUnityEngineRigidbodySleepMode2D(L, UnityEngine.RigidbodySleepMode2D.NeverSleep);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "StartAwake"))
                {
                    translator.PushUnityEngineRigidbodySleepMode2D(L, UnityEngine.RigidbodySleepMode2D.StartAwake);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "StartAsleep"))
                {
                    translator.PushUnityEngineRigidbodySleepMode2D(L, UnityEngine.RigidbodySleepMode2D.StartAsleep);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.RigidbodySleepMode2D!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RigidbodySleepMode2D! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCollisionDetectionMode2DWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.CollisionDetectionMode2D), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.CollisionDetectionMode2D), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.CollisionDetectionMode2D), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Discrete", UnityEngine.CollisionDetectionMode2D.Discrete);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Continuous", UnityEngine.CollisionDetectionMode2D.Continuous);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.CollisionDetectionMode2D), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCollisionDetectionMode2D(L, (UnityEngine.CollisionDetectionMode2D)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Discrete"))
                {
                    translator.PushUnityEngineCollisionDetectionMode2D(L, UnityEngine.CollisionDetectionMode2D.Discrete);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Continuous"))
                {
                    translator.PushUnityEngineCollisionDetectionMode2D(L, UnityEngine.CollisionDetectionMode2D.Continuous);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.CollisionDetectionMode2D!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.CollisionDetectionMode2D! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRigidbodyType2DWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.RigidbodyType2D), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.RigidbodyType2D), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.RigidbodyType2D), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Dynamic", UnityEngine.RigidbodyType2D.Dynamic);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Kinematic", UnityEngine.RigidbodyType2D.Kinematic);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Static", UnityEngine.RigidbodyType2D.Static);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.RigidbodyType2D), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRigidbodyType2D(L, (UnityEngine.RigidbodyType2D)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Dynamic"))
                {
                    translator.PushUnityEngineRigidbodyType2D(L, UnityEngine.RigidbodyType2D.Dynamic);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Kinematic"))
                {
                    translator.PushUnityEngineRigidbodyType2D(L, UnityEngine.RigidbodyType2D.Kinematic);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Static"))
                {
                    translator.PushUnityEngineRigidbodyType2D(L, UnityEngine.RigidbodyType2D.Static);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.RigidbodyType2D!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RigidbodyType2D! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineForceMode2DWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ForceMode2D), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ForceMode2D), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ForceMode2D), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Force", UnityEngine.ForceMode2D.Force);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Impulse", UnityEngine.ForceMode2D.Impulse);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ForceMode2D), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineForceMode2D(L, (UnityEngine.ForceMode2D)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Force"))
                {
                    translator.PushUnityEngineForceMode2D(L, UnityEngine.ForceMode2D.Force);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Impulse"))
                {
                    translator.PushUnityEngineForceMode2D(L, UnityEngine.ForceMode2D.Impulse);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ForceMode2D!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ForceMode2D! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineJointLimitState2DWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.JointLimitState2D), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.JointLimitState2D), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.JointLimitState2D), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Inactive", UnityEngine.JointLimitState2D.Inactive);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LowerLimit", UnityEngine.JointLimitState2D.LowerLimit);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UpperLimit", UnityEngine.JointLimitState2D.UpperLimit);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EqualLimits", UnityEngine.JointLimitState2D.EqualLimits);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.JointLimitState2D), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineJointLimitState2D(L, (UnityEngine.JointLimitState2D)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Inactive"))
                {
                    translator.PushUnityEngineJointLimitState2D(L, UnityEngine.JointLimitState2D.Inactive);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LowerLimit"))
                {
                    translator.PushUnityEngineJointLimitState2D(L, UnityEngine.JointLimitState2D.LowerLimit);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UpperLimit"))
                {
                    translator.PushUnityEngineJointLimitState2D(L, UnityEngine.JointLimitState2D.UpperLimit);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "EqualLimits"))
                {
                    translator.PushUnityEngineJointLimitState2D(L, UnityEngine.JointLimitState2D.EqualLimits);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.JointLimitState2D!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.JointLimitState2D! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineEffectorSelection2DWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.EffectorSelection2D), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.EffectorSelection2D), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.EffectorSelection2D), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Rigidbody", UnityEngine.EffectorSelection2D.Rigidbody);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Collider", UnityEngine.EffectorSelection2D.Collider);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.EffectorSelection2D), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineEffectorSelection2D(L, (UnityEngine.EffectorSelection2D)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Rigidbody"))
                {
                    translator.PushUnityEngineEffectorSelection2D(L, UnityEngine.EffectorSelection2D.Rigidbody);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Collider"))
                {
                    translator.PushUnityEngineEffectorSelection2D(L, UnityEngine.EffectorSelection2D.Collider);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.EffectorSelection2D!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.EffectorSelection2D! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineEffectorForceMode2DWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.EffectorForceMode2D), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.EffectorForceMode2D), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.EffectorForceMode2D), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Constant", UnityEngine.EffectorForceMode2D.Constant);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "InverseLinear", UnityEngine.EffectorForceMode2D.InverseLinear);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "InverseSquared", UnityEngine.EffectorForceMode2D.InverseSquared);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.EffectorForceMode2D), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineEffectorForceMode2D(L, (UnityEngine.EffectorForceMode2D)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Constant"))
                {
                    translator.PushUnityEngineEffectorForceMode2D(L, UnityEngine.EffectorForceMode2D.Constant);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "InverseLinear"))
                {
                    translator.PushUnityEngineEffectorForceMode2D(L, UnityEngine.EffectorForceMode2D.InverseLinear);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "InverseSquared"))
                {
                    translator.PushUnityEngineEffectorForceMode2D(L, UnityEngine.EffectorForceMode2D.InverseSquared);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.EffectorForceMode2D!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.EffectorForceMode2D! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCompositeCollider2DGeometryTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.CompositeCollider2D.GeometryType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.CompositeCollider2D.GeometryType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.CompositeCollider2D.GeometryType), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Outlines", UnityEngine.CompositeCollider2D.GeometryType.Outlines);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Polygons", UnityEngine.CompositeCollider2D.GeometryType.Polygons);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.CompositeCollider2D.GeometryType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCompositeCollider2DGeometryType(L, (UnityEngine.CompositeCollider2D.GeometryType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Outlines"))
                {
                    translator.PushUnityEngineCompositeCollider2DGeometryType(L, UnityEngine.CompositeCollider2D.GeometryType.Outlines);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Polygons"))
                {
                    translator.PushUnityEngineCompositeCollider2DGeometryType(L, UnityEngine.CompositeCollider2D.GeometryType.Polygons);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.CompositeCollider2D.GeometryType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.CompositeCollider2D.GeometryType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCompositeCollider2DGenerationTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.CompositeCollider2D.GenerationType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.CompositeCollider2D.GenerationType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.CompositeCollider2D.GenerationType), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Synchronous", UnityEngine.CompositeCollider2D.GenerationType.Synchronous);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Manual", UnityEngine.CompositeCollider2D.GenerationType.Manual);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.CompositeCollider2D.GenerationType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCompositeCollider2DGenerationType(L, (UnityEngine.CompositeCollider2D.GenerationType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Synchronous"))
                {
                    translator.PushUnityEngineCompositeCollider2DGenerationType(L, UnityEngine.CompositeCollider2D.GenerationType.Synchronous);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Manual"))
                {
                    translator.PushUnityEngineCompositeCollider2DGenerationType(L, UnityEngine.CompositeCollider2D.GenerationType.Manual);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.CompositeCollider2D.GenerationType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.CompositeCollider2D.GenerationType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRigidbodyConstraintsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.RigidbodyConstraints), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.RigidbodyConstraints), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.RigidbodyConstraints), L, null, 11, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.RigidbodyConstraints.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreezePositionX", UnityEngine.RigidbodyConstraints.FreezePositionX);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreezePositionY", UnityEngine.RigidbodyConstraints.FreezePositionY);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreezePositionZ", UnityEngine.RigidbodyConstraints.FreezePositionZ);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreezeRotationX", UnityEngine.RigidbodyConstraints.FreezeRotationX);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreezeRotationY", UnityEngine.RigidbodyConstraints.FreezeRotationY);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreezeRotationZ", UnityEngine.RigidbodyConstraints.FreezeRotationZ);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreezePosition", UnityEngine.RigidbodyConstraints.FreezePosition);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreezeRotation", UnityEngine.RigidbodyConstraints.FreezeRotation);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreezeAll", UnityEngine.RigidbodyConstraints.FreezeAll);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.RigidbodyConstraints), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRigidbodyConstraints(L, (UnityEngine.RigidbodyConstraints)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineRigidbodyConstraints(L, UnityEngine.RigidbodyConstraints.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FreezePositionX"))
                {
                    translator.PushUnityEngineRigidbodyConstraints(L, UnityEngine.RigidbodyConstraints.FreezePositionX);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FreezePositionY"))
                {
                    translator.PushUnityEngineRigidbodyConstraints(L, UnityEngine.RigidbodyConstraints.FreezePositionY);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FreezePositionZ"))
                {
                    translator.PushUnityEngineRigidbodyConstraints(L, UnityEngine.RigidbodyConstraints.FreezePositionZ);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FreezeRotationX"))
                {
                    translator.PushUnityEngineRigidbodyConstraints(L, UnityEngine.RigidbodyConstraints.FreezeRotationX);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FreezeRotationY"))
                {
                    translator.PushUnityEngineRigidbodyConstraints(L, UnityEngine.RigidbodyConstraints.FreezeRotationY);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FreezeRotationZ"))
                {
                    translator.PushUnityEngineRigidbodyConstraints(L, UnityEngine.RigidbodyConstraints.FreezeRotationZ);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FreezePosition"))
                {
                    translator.PushUnityEngineRigidbodyConstraints(L, UnityEngine.RigidbodyConstraints.FreezePosition);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FreezeRotation"))
                {
                    translator.PushUnityEngineRigidbodyConstraints(L, UnityEngine.RigidbodyConstraints.FreezeRotation);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FreezeAll"))
                {
                    translator.PushUnityEngineRigidbodyConstraints(L, UnityEngine.RigidbodyConstraints.FreezeAll);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.RigidbodyConstraints!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RigidbodyConstraints! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineForceModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ForceMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ForceMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ForceMode), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Force", UnityEngine.ForceMode.Force);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Acceleration", UnityEngine.ForceMode.Acceleration);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Impulse", UnityEngine.ForceMode.Impulse);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VelocityChange", UnityEngine.ForceMode.VelocityChange);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ForceMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineForceMode(L, (UnityEngine.ForceMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Force"))
                {
                    translator.PushUnityEngineForceMode(L, UnityEngine.ForceMode.Force);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Acceleration"))
                {
                    translator.PushUnityEngineForceMode(L, UnityEngine.ForceMode.Acceleration);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Impulse"))
                {
                    translator.PushUnityEngineForceMode(L, UnityEngine.ForceMode.Impulse);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "VelocityChange"))
                {
                    translator.PushUnityEngineForceMode(L, UnityEngine.ForceMode.VelocityChange);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ForceMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ForceMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineJointProjectionModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.JointProjectionMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.JointProjectionMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.JointProjectionMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.JointProjectionMode.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PositionAndRotation", UnityEngine.JointProjectionMode.PositionAndRotation);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.JointProjectionMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineJointProjectionMode(L, (UnityEngine.JointProjectionMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineJointProjectionMode(L, UnityEngine.JointProjectionMode.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PositionAndRotation"))
                {
                    translator.PushUnityEngineJointProjectionMode(L, UnityEngine.JointProjectionMode.PositionAndRotation);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.JointProjectionMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.JointProjectionMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineMeshColliderCookingOptionsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.MeshColliderCookingOptions), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.MeshColliderCookingOptions), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.MeshColliderCookingOptions), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.MeshColliderCookingOptions.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CookForFasterSimulation", UnityEngine.MeshColliderCookingOptions.CookForFasterSimulation);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EnableMeshCleaning", UnityEngine.MeshColliderCookingOptions.EnableMeshCleaning);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WeldColocatedVertices", UnityEngine.MeshColliderCookingOptions.WeldColocatedVertices);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UseFastMidphase", UnityEngine.MeshColliderCookingOptions.UseFastMidphase);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.MeshColliderCookingOptions), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineMeshColliderCookingOptions(L, (UnityEngine.MeshColliderCookingOptions)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineMeshColliderCookingOptions(L, UnityEngine.MeshColliderCookingOptions.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CookForFasterSimulation"))
                {
                    translator.PushUnityEngineMeshColliderCookingOptions(L, UnityEngine.MeshColliderCookingOptions.CookForFasterSimulation);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "EnableMeshCleaning"))
                {
                    translator.PushUnityEngineMeshColliderCookingOptions(L, UnityEngine.MeshColliderCookingOptions.EnableMeshCleaning);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "WeldColocatedVertices"))
                {
                    translator.PushUnityEngineMeshColliderCookingOptions(L, UnityEngine.MeshColliderCookingOptions.WeldColocatedVertices);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UseFastMidphase"))
                {
                    translator.PushUnityEngineMeshColliderCookingOptions(L, UnityEngine.MeshColliderCookingOptions.UseFastMidphase);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.MeshColliderCookingOptions!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.MeshColliderCookingOptions! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRigidbodyInterpolationWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.RigidbodyInterpolation), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.RigidbodyInterpolation), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.RigidbodyInterpolation), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.RigidbodyInterpolation.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Interpolate", UnityEngine.RigidbodyInterpolation.Interpolate);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Extrapolate", UnityEngine.RigidbodyInterpolation.Extrapolate);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.RigidbodyInterpolation), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRigidbodyInterpolation(L, (UnityEngine.RigidbodyInterpolation)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineRigidbodyInterpolation(L, UnityEngine.RigidbodyInterpolation.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Interpolate"))
                {
                    translator.PushUnityEngineRigidbodyInterpolation(L, UnityEngine.RigidbodyInterpolation.Interpolate);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Extrapolate"))
                {
                    translator.PushUnityEngineRigidbodyInterpolation(L, UnityEngine.RigidbodyInterpolation.Extrapolate);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.RigidbodyInterpolation!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RigidbodyInterpolation! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEnginePhysicMaterialCombineWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.PhysicMaterialCombine), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.PhysicMaterialCombine), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.PhysicMaterialCombine), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Average", UnityEngine.PhysicMaterialCombine.Average);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Minimum", UnityEngine.PhysicMaterialCombine.Minimum);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Multiply", UnityEngine.PhysicMaterialCombine.Multiply);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Maximum", UnityEngine.PhysicMaterialCombine.Maximum);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.PhysicMaterialCombine), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEnginePhysicMaterialCombine(L, (UnityEngine.PhysicMaterialCombine)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Average"))
                {
                    translator.PushUnityEnginePhysicMaterialCombine(L, UnityEngine.PhysicMaterialCombine.Average);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Minimum"))
                {
                    translator.PushUnityEnginePhysicMaterialCombine(L, UnityEngine.PhysicMaterialCombine.Minimum);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Multiply"))
                {
                    translator.PushUnityEnginePhysicMaterialCombine(L, UnityEngine.PhysicMaterialCombine.Multiply);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Maximum"))
                {
                    translator.PushUnityEnginePhysicMaterialCombine(L, UnityEngine.PhysicMaterialCombine.Maximum);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.PhysicMaterialCombine!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.PhysicMaterialCombine! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCollisionFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.CollisionFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.CollisionFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.CollisionFlags), L, null, 8, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.CollisionFlags.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Sides", UnityEngine.CollisionFlags.Sides);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Above", UnityEngine.CollisionFlags.Above);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Below", UnityEngine.CollisionFlags.Below);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CollidedSides", UnityEngine.CollisionFlags.CollidedSides);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CollidedAbove", UnityEngine.CollisionFlags.CollidedAbove);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CollidedBelow", UnityEngine.CollisionFlags.CollidedBelow);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.CollisionFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCollisionFlags(L, (UnityEngine.CollisionFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineCollisionFlags(L, UnityEngine.CollisionFlags.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Sides"))
                {
                    translator.PushUnityEngineCollisionFlags(L, UnityEngine.CollisionFlags.Sides);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Above"))
                {
                    translator.PushUnityEngineCollisionFlags(L, UnityEngine.CollisionFlags.Above);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Below"))
                {
                    translator.PushUnityEngineCollisionFlags(L, UnityEngine.CollisionFlags.Below);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CollidedSides"))
                {
                    translator.PushUnityEngineCollisionFlags(L, UnityEngine.CollisionFlags.CollidedSides);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CollidedAbove"))
                {
                    translator.PushUnityEngineCollisionFlags(L, UnityEngine.CollisionFlags.CollidedAbove);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CollidedBelow"))
                {
                    translator.PushUnityEngineCollisionFlags(L, UnityEngine.CollisionFlags.CollidedBelow);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.CollisionFlags!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.CollisionFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineQueryTriggerInteractionWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.QueryTriggerInteraction), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.QueryTriggerInteraction), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.QueryTriggerInteraction), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UseGlobal", UnityEngine.QueryTriggerInteraction.UseGlobal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Ignore", UnityEngine.QueryTriggerInteraction.Ignore);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Collide", UnityEngine.QueryTriggerInteraction.Collide);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.QueryTriggerInteraction), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineQueryTriggerInteraction(L, (UnityEngine.QueryTriggerInteraction)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "UseGlobal"))
                {
                    translator.PushUnityEngineQueryTriggerInteraction(L, UnityEngine.QueryTriggerInteraction.UseGlobal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Ignore"))
                {
                    translator.PushUnityEngineQueryTriggerInteraction(L, UnityEngine.QueryTriggerInteraction.Ignore);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Collide"))
                {
                    translator.PushUnityEngineQueryTriggerInteraction(L, UnityEngine.QueryTriggerInteraction.Collide);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.QueryTriggerInteraction!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.QueryTriggerInteraction! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineCollisionDetectionModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.CollisionDetectionMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.CollisionDetectionMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.CollisionDetectionMode), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Discrete", UnityEngine.CollisionDetectionMode.Discrete);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Continuous", UnityEngine.CollisionDetectionMode.Continuous);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ContinuousDynamic", UnityEngine.CollisionDetectionMode.ContinuousDynamic);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ContinuousSpeculative", UnityEngine.CollisionDetectionMode.ContinuousSpeculative);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.CollisionDetectionMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineCollisionDetectionMode(L, (UnityEngine.CollisionDetectionMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Discrete"))
                {
                    translator.PushUnityEngineCollisionDetectionMode(L, UnityEngine.CollisionDetectionMode.Discrete);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Continuous"))
                {
                    translator.PushUnityEngineCollisionDetectionMode(L, UnityEngine.CollisionDetectionMode.Continuous);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ContinuousDynamic"))
                {
                    translator.PushUnityEngineCollisionDetectionMode(L, UnityEngine.CollisionDetectionMode.ContinuousDynamic);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ContinuousSpeculative"))
                {
                    translator.PushUnityEngineCollisionDetectionMode(L, UnityEngine.CollisionDetectionMode.ContinuousSpeculative);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.CollisionDetectionMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.CollisionDetectionMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRotationDriveModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.RotationDriveMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.RotationDriveMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.RotationDriveMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "XYAndZ", UnityEngine.RotationDriveMode.XYAndZ);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Slerp", UnityEngine.RotationDriveMode.Slerp);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.RotationDriveMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRotationDriveMode(L, (UnityEngine.RotationDriveMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "XYAndZ"))
                {
                    translator.PushUnityEngineRotationDriveMode(L, UnityEngine.RotationDriveMode.XYAndZ);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Slerp"))
                {
                    translator.PushUnityEngineRotationDriveMode(L, UnityEngine.RotationDriveMode.Slerp);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.RotationDriveMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RotationDriveMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineArticulationJointTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ArticulationJointType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ArticulationJointType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ArticulationJointType), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FixedJoint", UnityEngine.ArticulationJointType.FixedJoint);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PrismaticJoint", UnityEngine.ArticulationJointType.PrismaticJoint);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RevoluteJoint", UnityEngine.ArticulationJointType.RevoluteJoint);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SphericalJoint", UnityEngine.ArticulationJointType.SphericalJoint);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ArticulationJointType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineArticulationJointType(L, (UnityEngine.ArticulationJointType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "FixedJoint"))
                {
                    translator.PushUnityEngineArticulationJointType(L, UnityEngine.ArticulationJointType.FixedJoint);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "PrismaticJoint"))
                {
                    translator.PushUnityEngineArticulationJointType(L, UnityEngine.ArticulationJointType.PrismaticJoint);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RevoluteJoint"))
                {
                    translator.PushUnityEngineArticulationJointType(L, UnityEngine.ArticulationJointType.RevoluteJoint);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SphericalJoint"))
                {
                    translator.PushUnityEngineArticulationJointType(L, UnityEngine.ArticulationJointType.SphericalJoint);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ArticulationJointType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ArticulationJointType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineArticulationDofLockWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ArticulationDofLock), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ArticulationDofLock), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ArticulationDofLock), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LockedMotion", UnityEngine.ArticulationDofLock.LockedMotion);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LimitedMotion", UnityEngine.ArticulationDofLock.LimitedMotion);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreeMotion", UnityEngine.ArticulationDofLock.FreeMotion);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ArticulationDofLock), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineArticulationDofLock(L, (UnityEngine.ArticulationDofLock)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "LockedMotion"))
                {
                    translator.PushUnityEngineArticulationDofLock(L, UnityEngine.ArticulationDofLock.LockedMotion);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LimitedMotion"))
                {
                    translator.PushUnityEngineArticulationDofLock(L, UnityEngine.ArticulationDofLock.LimitedMotion);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FreeMotion"))
                {
                    translator.PushUnityEngineArticulationDofLock(L, UnityEngine.ArticulationDofLock.FreeMotion);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ArticulationDofLock!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ArticulationDofLock! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineScreenCaptureStereoScreenCaptureModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.ScreenCapture.StereoScreenCaptureMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.ScreenCapture.StereoScreenCaptureMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.ScreenCapture.StereoScreenCaptureMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeftEye", UnityEngine.ScreenCapture.StereoScreenCaptureMode.LeftEye);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RightEye", UnityEngine.ScreenCapture.StereoScreenCaptureMode.RightEye);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BothEyes", UnityEngine.ScreenCapture.StereoScreenCaptureMode.BothEyes);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.ScreenCapture.StereoScreenCaptureMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineScreenCaptureStereoScreenCaptureMode(L, (UnityEngine.ScreenCapture.StereoScreenCaptureMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "LeftEye"))
                {
                    translator.PushUnityEngineScreenCaptureStereoScreenCaptureMode(L, UnityEngine.ScreenCapture.StereoScreenCaptureMode.LeftEye);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RightEye"))
                {
                    translator.PushUnityEngineScreenCaptureStereoScreenCaptureMode(L, UnityEngine.ScreenCapture.StereoScreenCaptureMode.RightEye);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BothEyes"))
                {
                    translator.PushUnityEngineScreenCaptureStereoScreenCaptureMode(L, UnityEngine.ScreenCapture.StereoScreenCaptureMode.BothEyes);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.ScreenCapture.StereoScreenCaptureMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.ScreenCapture.StereoScreenCaptureMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineTextCoreLowLevelFontFeatureLookupFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.TextCore.LowLevel.FontFeatureLookupFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.TextCore.LowLevel.FontFeatureLookupFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.TextCore.LowLevel.FontFeatureLookupFlags), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.TextCore.LowLevel.FontFeatureLookupFlags.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IgnoreLigatures", UnityEngine.TextCore.LowLevel.FontFeatureLookupFlags.IgnoreLigatures);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IgnoreSpacingAdjustments", UnityEngine.TextCore.LowLevel.FontFeatureLookupFlags.IgnoreSpacingAdjustments);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.TextCore.LowLevel.FontFeatureLookupFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineTextCoreLowLevelFontFeatureLookupFlags(L, (UnityEngine.TextCore.LowLevel.FontFeatureLookupFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineTextCoreLowLevelFontFeatureLookupFlags(L, UnityEngine.TextCore.LowLevel.FontFeatureLookupFlags.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "IgnoreLigatures"))
                {
                    translator.PushUnityEngineTextCoreLowLevelFontFeatureLookupFlags(L, UnityEngine.TextCore.LowLevel.FontFeatureLookupFlags.IgnoreLigatures);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "IgnoreSpacingAdjustments"))
                {
                    translator.PushUnityEngineTextCoreLowLevelFontFeatureLookupFlags(L, UnityEngine.TextCore.LowLevel.FontFeatureLookupFlags.IgnoreSpacingAdjustments);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.TextCore.LowLevel.FontFeatureLookupFlags!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.TextCore.LowLevel.FontFeatureLookupFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineTextCoreLowLevelGlyphLoadFlagsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.TextCore.LowLevel.GlyphLoadFlags), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.TextCore.LowLevel.GlyphLoadFlags), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.TextCore.LowLevel.GlyphLoadFlags), L, null, 11, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LOAD_DEFAULT", UnityEngine.TextCore.LowLevel.GlyphLoadFlags.LOAD_DEFAULT);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LOAD_NO_SCALE", UnityEngine.TextCore.LowLevel.GlyphLoadFlags.LOAD_NO_SCALE);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LOAD_NO_HINTING", UnityEngine.TextCore.LowLevel.GlyphLoadFlags.LOAD_NO_HINTING);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LOAD_RENDER", UnityEngine.TextCore.LowLevel.GlyphLoadFlags.LOAD_RENDER);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LOAD_NO_BITMAP", UnityEngine.TextCore.LowLevel.GlyphLoadFlags.LOAD_NO_BITMAP);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LOAD_FORCE_AUTOHINT", UnityEngine.TextCore.LowLevel.GlyphLoadFlags.LOAD_FORCE_AUTOHINT);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LOAD_MONOCHROME", UnityEngine.TextCore.LowLevel.GlyphLoadFlags.LOAD_MONOCHROME);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LOAD_NO_AUTOHINT", UnityEngine.TextCore.LowLevel.GlyphLoadFlags.LOAD_NO_AUTOHINT);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LOAD_COMPUTE_METRICS", UnityEngine.TextCore.LowLevel.GlyphLoadFlags.LOAD_COMPUTE_METRICS);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LOAD_BITMAP_METRICS_ONLY", UnityEngine.TextCore.LowLevel.GlyphLoadFlags.LOAD_BITMAP_METRICS_ONLY);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.TextCore.LowLevel.GlyphLoadFlags), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineTextCoreLowLevelGlyphLoadFlags(L, (UnityEngine.TextCore.LowLevel.GlyphLoadFlags)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "LOAD_DEFAULT"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphLoadFlags(L, UnityEngine.TextCore.LowLevel.GlyphLoadFlags.LOAD_DEFAULT);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LOAD_NO_SCALE"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphLoadFlags(L, UnityEngine.TextCore.LowLevel.GlyphLoadFlags.LOAD_NO_SCALE);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LOAD_NO_HINTING"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphLoadFlags(L, UnityEngine.TextCore.LowLevel.GlyphLoadFlags.LOAD_NO_HINTING);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LOAD_RENDER"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphLoadFlags(L, UnityEngine.TextCore.LowLevel.GlyphLoadFlags.LOAD_RENDER);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LOAD_NO_BITMAP"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphLoadFlags(L, UnityEngine.TextCore.LowLevel.GlyphLoadFlags.LOAD_NO_BITMAP);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LOAD_FORCE_AUTOHINT"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphLoadFlags(L, UnityEngine.TextCore.LowLevel.GlyphLoadFlags.LOAD_FORCE_AUTOHINT);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LOAD_MONOCHROME"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphLoadFlags(L, UnityEngine.TextCore.LowLevel.GlyphLoadFlags.LOAD_MONOCHROME);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LOAD_NO_AUTOHINT"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphLoadFlags(L, UnityEngine.TextCore.LowLevel.GlyphLoadFlags.LOAD_NO_AUTOHINT);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LOAD_COMPUTE_METRICS"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphLoadFlags(L, UnityEngine.TextCore.LowLevel.GlyphLoadFlags.LOAD_COMPUTE_METRICS);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LOAD_BITMAP_METRICS_ONLY"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphLoadFlags(L, UnityEngine.TextCore.LowLevel.GlyphLoadFlags.LOAD_BITMAP_METRICS_ONLY);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.TextCore.LowLevel.GlyphLoadFlags!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.TextCore.LowLevel.GlyphLoadFlags! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineTextCoreLowLevelFontEngineErrorWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.TextCore.LowLevel.FontEngineError), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.TextCore.LowLevel.FontEngineError), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.TextCore.LowLevel.FontEngineError), L, null, 15, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Success", UnityEngine.TextCore.LowLevel.FontEngineError.Success);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Invalid_File_Path", UnityEngine.TextCore.LowLevel.FontEngineError.Invalid_File_Path);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Invalid_File_Format", UnityEngine.TextCore.LowLevel.FontEngineError.Invalid_File_Format);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Invalid_File_Structure", UnityEngine.TextCore.LowLevel.FontEngineError.Invalid_File_Structure);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Invalid_File", UnityEngine.TextCore.LowLevel.FontEngineError.Invalid_File);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Invalid_Table", UnityEngine.TextCore.LowLevel.FontEngineError.Invalid_Table);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Invalid_Glyph_Index", UnityEngine.TextCore.LowLevel.FontEngineError.Invalid_Glyph_Index);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Invalid_Character_Code", UnityEngine.TextCore.LowLevel.FontEngineError.Invalid_Character_Code);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Invalid_Pixel_Size", UnityEngine.TextCore.LowLevel.FontEngineError.Invalid_Pixel_Size);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Invalid_Library", UnityEngine.TextCore.LowLevel.FontEngineError.Invalid_Library);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Invalid_Face", UnityEngine.TextCore.LowLevel.FontEngineError.Invalid_Face);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Invalid_Library_or_Face", UnityEngine.TextCore.LowLevel.FontEngineError.Invalid_Library_or_Face);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Atlas_Generation_Cancelled", UnityEngine.TextCore.LowLevel.FontEngineError.Atlas_Generation_Cancelled);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Invalid_SharedTextureData", UnityEngine.TextCore.LowLevel.FontEngineError.Invalid_SharedTextureData);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.TextCore.LowLevel.FontEngineError), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineTextCoreLowLevelFontEngineError(L, (UnityEngine.TextCore.LowLevel.FontEngineError)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Success"))
                {
                    translator.PushUnityEngineTextCoreLowLevelFontEngineError(L, UnityEngine.TextCore.LowLevel.FontEngineError.Success);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Invalid_File_Path"))
                {
                    translator.PushUnityEngineTextCoreLowLevelFontEngineError(L, UnityEngine.TextCore.LowLevel.FontEngineError.Invalid_File_Path);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Invalid_File_Format"))
                {
                    translator.PushUnityEngineTextCoreLowLevelFontEngineError(L, UnityEngine.TextCore.LowLevel.FontEngineError.Invalid_File_Format);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Invalid_File_Structure"))
                {
                    translator.PushUnityEngineTextCoreLowLevelFontEngineError(L, UnityEngine.TextCore.LowLevel.FontEngineError.Invalid_File_Structure);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Invalid_File"))
                {
                    translator.PushUnityEngineTextCoreLowLevelFontEngineError(L, UnityEngine.TextCore.LowLevel.FontEngineError.Invalid_File);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Invalid_Table"))
                {
                    translator.PushUnityEngineTextCoreLowLevelFontEngineError(L, UnityEngine.TextCore.LowLevel.FontEngineError.Invalid_Table);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Invalid_Glyph_Index"))
                {
                    translator.PushUnityEngineTextCoreLowLevelFontEngineError(L, UnityEngine.TextCore.LowLevel.FontEngineError.Invalid_Glyph_Index);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Invalid_Character_Code"))
                {
                    translator.PushUnityEngineTextCoreLowLevelFontEngineError(L, UnityEngine.TextCore.LowLevel.FontEngineError.Invalid_Character_Code);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Invalid_Pixel_Size"))
                {
                    translator.PushUnityEngineTextCoreLowLevelFontEngineError(L, UnityEngine.TextCore.LowLevel.FontEngineError.Invalid_Pixel_Size);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Invalid_Library"))
                {
                    translator.PushUnityEngineTextCoreLowLevelFontEngineError(L, UnityEngine.TextCore.LowLevel.FontEngineError.Invalid_Library);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Invalid_Face"))
                {
                    translator.PushUnityEngineTextCoreLowLevelFontEngineError(L, UnityEngine.TextCore.LowLevel.FontEngineError.Invalid_Face);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Invalid_Library_or_Face"))
                {
                    translator.PushUnityEngineTextCoreLowLevelFontEngineError(L, UnityEngine.TextCore.LowLevel.FontEngineError.Invalid_Library_or_Face);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Atlas_Generation_Cancelled"))
                {
                    translator.PushUnityEngineTextCoreLowLevelFontEngineError(L, UnityEngine.TextCore.LowLevel.FontEngineError.Atlas_Generation_Cancelled);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Invalid_SharedTextureData"))
                {
                    translator.PushUnityEngineTextCoreLowLevelFontEngineError(L, UnityEngine.TextCore.LowLevel.FontEngineError.Invalid_SharedTextureData);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.TextCore.LowLevel.FontEngineError!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.TextCore.LowLevel.FontEngineError! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineTextCoreLowLevelGlyphRenderModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.TextCore.LowLevel.GlyphRenderMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.TextCore.LowLevel.GlyphRenderMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.TextCore.LowLevel.GlyphRenderMode), L, null, 11, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SMOOTH_HINTED", UnityEngine.TextCore.LowLevel.GlyphRenderMode.SMOOTH_HINTED);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SMOOTH", UnityEngine.TextCore.LowLevel.GlyphRenderMode.SMOOTH);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RASTER_HINTED", UnityEngine.TextCore.LowLevel.GlyphRenderMode.RASTER_HINTED);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RASTER", UnityEngine.TextCore.LowLevel.GlyphRenderMode.RASTER);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SDF", UnityEngine.TextCore.LowLevel.GlyphRenderMode.SDF);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SDF8", UnityEngine.TextCore.LowLevel.GlyphRenderMode.SDF8);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SDF16", UnityEngine.TextCore.LowLevel.GlyphRenderMode.SDF16);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SDF32", UnityEngine.TextCore.LowLevel.GlyphRenderMode.SDF32);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SDFAA_HINTED", UnityEngine.TextCore.LowLevel.GlyphRenderMode.SDFAA_HINTED);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SDFAA", UnityEngine.TextCore.LowLevel.GlyphRenderMode.SDFAA);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.TextCore.LowLevel.GlyphRenderMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineTextCoreLowLevelGlyphRenderMode(L, (UnityEngine.TextCore.LowLevel.GlyphRenderMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "SMOOTH_HINTED"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphRenderMode(L, UnityEngine.TextCore.LowLevel.GlyphRenderMode.SMOOTH_HINTED);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SMOOTH"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphRenderMode(L, UnityEngine.TextCore.LowLevel.GlyphRenderMode.SMOOTH);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RASTER_HINTED"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphRenderMode(L, UnityEngine.TextCore.LowLevel.GlyphRenderMode.RASTER_HINTED);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RASTER"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphRenderMode(L, UnityEngine.TextCore.LowLevel.GlyphRenderMode.RASTER);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SDF"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphRenderMode(L, UnityEngine.TextCore.LowLevel.GlyphRenderMode.SDF);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SDF8"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphRenderMode(L, UnityEngine.TextCore.LowLevel.GlyphRenderMode.SDF8);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SDF16"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphRenderMode(L, UnityEngine.TextCore.LowLevel.GlyphRenderMode.SDF16);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SDF32"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphRenderMode(L, UnityEngine.TextCore.LowLevel.GlyphRenderMode.SDF32);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SDFAA_HINTED"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphRenderMode(L, UnityEngine.TextCore.LowLevel.GlyphRenderMode.SDFAA_HINTED);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SDFAA"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphRenderMode(L, UnityEngine.TextCore.LowLevel.GlyphRenderMode.SDFAA);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.TextCore.LowLevel.GlyphRenderMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.TextCore.LowLevel.GlyphRenderMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineTextCoreLowLevelGlyphPackingModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.TextCore.LowLevel.GlyphPackingMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.TextCore.LowLevel.GlyphPackingMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.TextCore.LowLevel.GlyphPackingMode), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BestShortSideFit", UnityEngine.TextCore.LowLevel.GlyphPackingMode.BestShortSideFit);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BestLongSideFit", UnityEngine.TextCore.LowLevel.GlyphPackingMode.BestLongSideFit);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BestAreaFit", UnityEngine.TextCore.LowLevel.GlyphPackingMode.BestAreaFit);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BottomLeftRule", UnityEngine.TextCore.LowLevel.GlyphPackingMode.BottomLeftRule);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ContactPointRule", UnityEngine.TextCore.LowLevel.GlyphPackingMode.ContactPointRule);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.TextCore.LowLevel.GlyphPackingMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineTextCoreLowLevelGlyphPackingMode(L, (UnityEngine.TextCore.LowLevel.GlyphPackingMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "BestShortSideFit"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphPackingMode(L, UnityEngine.TextCore.LowLevel.GlyphPackingMode.BestShortSideFit);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BestLongSideFit"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphPackingMode(L, UnityEngine.TextCore.LowLevel.GlyphPackingMode.BestLongSideFit);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BestAreaFit"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphPackingMode(L, UnityEngine.TextCore.LowLevel.GlyphPackingMode.BestAreaFit);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BottomLeftRule"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphPackingMode(L, UnityEngine.TextCore.LowLevel.GlyphPackingMode.BottomLeftRule);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ContactPointRule"))
                {
                    translator.PushUnityEngineTextCoreLowLevelGlyphPackingMode(L, UnityEngine.TextCore.LowLevel.GlyphPackingMode.ContactPointRule);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.TextCore.LowLevel.GlyphPackingMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.TextCore.LowLevel.GlyphPackingMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineTextAnchorWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.TextAnchor), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.TextAnchor), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.TextAnchor), L, null, 10, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UpperLeft", UnityEngine.TextAnchor.UpperLeft);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UpperCenter", UnityEngine.TextAnchor.UpperCenter);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UpperRight", UnityEngine.TextAnchor.UpperRight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MiddleLeft", UnityEngine.TextAnchor.MiddleLeft);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MiddleCenter", UnityEngine.TextAnchor.MiddleCenter);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MiddleRight", UnityEngine.TextAnchor.MiddleRight);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LowerLeft", UnityEngine.TextAnchor.LowerLeft);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LowerCenter", UnityEngine.TextAnchor.LowerCenter);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LowerRight", UnityEngine.TextAnchor.LowerRight);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.TextAnchor), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineTextAnchor(L, (UnityEngine.TextAnchor)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "UpperLeft"))
                {
                    translator.PushUnityEngineTextAnchor(L, UnityEngine.TextAnchor.UpperLeft);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UpperCenter"))
                {
                    translator.PushUnityEngineTextAnchor(L, UnityEngine.TextAnchor.UpperCenter);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UpperRight"))
                {
                    translator.PushUnityEngineTextAnchor(L, UnityEngine.TextAnchor.UpperRight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MiddleLeft"))
                {
                    translator.PushUnityEngineTextAnchor(L, UnityEngine.TextAnchor.MiddleLeft);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MiddleCenter"))
                {
                    translator.PushUnityEngineTextAnchor(L, UnityEngine.TextAnchor.MiddleCenter);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MiddleRight"))
                {
                    translator.PushUnityEngineTextAnchor(L, UnityEngine.TextAnchor.MiddleRight);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LowerLeft"))
                {
                    translator.PushUnityEngineTextAnchor(L, UnityEngine.TextAnchor.LowerLeft);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LowerCenter"))
                {
                    translator.PushUnityEngineTextAnchor(L, UnityEngine.TextAnchor.LowerCenter);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "LowerRight"))
                {
                    translator.PushUnityEngineTextAnchor(L, UnityEngine.TextAnchor.LowerRight);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.TextAnchor!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.TextAnchor! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineHorizontalWrapModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.HorizontalWrapMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.HorizontalWrapMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.HorizontalWrapMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Wrap", UnityEngine.HorizontalWrapMode.Wrap);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Overflow", UnityEngine.HorizontalWrapMode.Overflow);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.HorizontalWrapMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineHorizontalWrapMode(L, (UnityEngine.HorizontalWrapMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Wrap"))
                {
                    translator.PushUnityEngineHorizontalWrapMode(L, UnityEngine.HorizontalWrapMode.Wrap);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Overflow"))
                {
                    translator.PushUnityEngineHorizontalWrapMode(L, UnityEngine.HorizontalWrapMode.Overflow);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.HorizontalWrapMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.HorizontalWrapMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineVerticalWrapModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.VerticalWrapMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.VerticalWrapMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.VerticalWrapMode), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Truncate", UnityEngine.VerticalWrapMode.Truncate);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Overflow", UnityEngine.VerticalWrapMode.Overflow);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.VerticalWrapMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineVerticalWrapMode(L, (UnityEngine.VerticalWrapMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Truncate"))
                {
                    translator.PushUnityEngineVerticalWrapMode(L, UnityEngine.VerticalWrapMode.Truncate);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Overflow"))
                {
                    translator.PushUnityEngineVerticalWrapMode(L, UnityEngine.VerticalWrapMode.Overflow);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.VerticalWrapMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.VerticalWrapMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineGridBrushBaseToolWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.GridBrushBase.Tool), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.GridBrushBase.Tool), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.GridBrushBase.Tool), L, null, 8, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Select", UnityEngine.GridBrushBase.Tool.Select);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Move", UnityEngine.GridBrushBase.Tool.Move);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Paint", UnityEngine.GridBrushBase.Tool.Paint);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Box", UnityEngine.GridBrushBase.Tool.Box);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pick", UnityEngine.GridBrushBase.Tool.Pick);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Erase", UnityEngine.GridBrushBase.Tool.Erase);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FloodFill", UnityEngine.GridBrushBase.Tool.FloodFill);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.GridBrushBase.Tool), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineGridBrushBaseTool(L, (UnityEngine.GridBrushBase.Tool)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Select"))
                {
                    translator.PushUnityEngineGridBrushBaseTool(L, UnityEngine.GridBrushBase.Tool.Select);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Move"))
                {
                    translator.PushUnityEngineGridBrushBaseTool(L, UnityEngine.GridBrushBase.Tool.Move);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Paint"))
                {
                    translator.PushUnityEngineGridBrushBaseTool(L, UnityEngine.GridBrushBase.Tool.Paint);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Box"))
                {
                    translator.PushUnityEngineGridBrushBaseTool(L, UnityEngine.GridBrushBase.Tool.Box);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Pick"))
                {
                    translator.PushUnityEngineGridBrushBaseTool(L, UnityEngine.GridBrushBase.Tool.Pick);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Erase"))
                {
                    translator.PushUnityEngineGridBrushBaseTool(L, UnityEngine.GridBrushBase.Tool.Erase);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FloodFill"))
                {
                    translator.PushUnityEngineGridBrushBaseTool(L, UnityEngine.GridBrushBase.Tool.FloodFill);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.GridBrushBase.Tool!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.GridBrushBase.Tool! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineGridBrushBaseRotationDirectionWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.GridBrushBase.RotationDirection), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.GridBrushBase.RotationDirection), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.GridBrushBase.RotationDirection), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Clockwise", UnityEngine.GridBrushBase.RotationDirection.Clockwise);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CounterClockwise", UnityEngine.GridBrushBase.RotationDirection.CounterClockwise);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.GridBrushBase.RotationDirection), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineGridBrushBaseRotationDirection(L, (UnityEngine.GridBrushBase.RotationDirection)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Clockwise"))
                {
                    translator.PushUnityEngineGridBrushBaseRotationDirection(L, UnityEngine.GridBrushBase.RotationDirection.Clockwise);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CounterClockwise"))
                {
                    translator.PushUnityEngineGridBrushBaseRotationDirection(L, UnityEngine.GridBrushBase.RotationDirection.CounterClockwise);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.GridBrushBase.RotationDirection!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.GridBrushBase.RotationDirection! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineGridBrushBaseFlipAxisWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.GridBrushBase.FlipAxis), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.GridBrushBase.FlipAxis), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.GridBrushBase.FlipAxis), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "X", UnityEngine.GridBrushBase.FlipAxis.X);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Y", UnityEngine.GridBrushBase.FlipAxis.Y);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.GridBrushBase.FlipAxis), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineGridBrushBaseFlipAxis(L, (UnityEngine.GridBrushBase.FlipAxis)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "X"))
                {
                    translator.PushUnityEngineGridBrushBaseFlipAxis(L, UnityEngine.GridBrushBase.FlipAxis.X);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Y"))
                {
                    translator.PushUnityEngineGridBrushBaseFlipAxis(L, UnityEngine.GridBrushBase.FlipAxis.Y);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.GridBrushBase.FlipAxis!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.GridBrushBase.FlipAxis! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineRenderModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.RenderMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.RenderMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.RenderMode), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ScreenSpaceOverlay", UnityEngine.RenderMode.ScreenSpaceOverlay);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ScreenSpaceCamera", UnityEngine.RenderMode.ScreenSpaceCamera);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WorldSpace", UnityEngine.RenderMode.WorldSpace);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.RenderMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineRenderMode(L, (UnityEngine.RenderMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "ScreenSpaceOverlay"))
                {
                    translator.PushUnityEngineRenderMode(L, UnityEngine.RenderMode.ScreenSpaceOverlay);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ScreenSpaceCamera"))
                {
                    translator.PushUnityEngineRenderMode(L, UnityEngine.RenderMode.ScreenSpaceCamera);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "WorldSpace"))
                {
                    translator.PushUnityEngineRenderMode(L, UnityEngine.RenderMode.WorldSpace);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.RenderMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RenderMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineAdditionalCanvasShaderChannelsWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.AdditionalCanvasShaderChannels), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.AdditionalCanvasShaderChannels), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.AdditionalCanvasShaderChannels), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.AdditionalCanvasShaderChannels.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TexCoord1", UnityEngine.AdditionalCanvasShaderChannels.TexCoord1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TexCoord2", UnityEngine.AdditionalCanvasShaderChannels.TexCoord2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TexCoord3", UnityEngine.AdditionalCanvasShaderChannels.TexCoord3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", UnityEngine.AdditionalCanvasShaderChannels.Normal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Tangent", UnityEngine.AdditionalCanvasShaderChannels.Tangent);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.AdditionalCanvasShaderChannels), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineAdditionalCanvasShaderChannels(L, (UnityEngine.AdditionalCanvasShaderChannels)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineAdditionalCanvasShaderChannels(L, UnityEngine.AdditionalCanvasShaderChannels.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TexCoord1"))
                {
                    translator.PushUnityEngineAdditionalCanvasShaderChannels(L, UnityEngine.AdditionalCanvasShaderChannels.TexCoord1);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TexCoord2"))
                {
                    translator.PushUnityEngineAdditionalCanvasShaderChannels(L, UnityEngine.AdditionalCanvasShaderChannels.TexCoord2);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "TexCoord3"))
                {
                    translator.PushUnityEngineAdditionalCanvasShaderChannels(L, UnityEngine.AdditionalCanvasShaderChannels.TexCoord3);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
                {
                    translator.PushUnityEngineAdditionalCanvasShaderChannels(L, UnityEngine.AdditionalCanvasShaderChannels.Normal);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Tangent"))
                {
                    translator.PushUnityEngineAdditionalCanvasShaderChannels(L, UnityEngine.AdditionalCanvasShaderChannels.Tangent);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.AdditionalCanvasShaderChannels!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AdditionalCanvasShaderChannels! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineUISystemProfilerApiSampleTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.UISystemProfilerApi.SampleType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.UISystemProfilerApi.SampleType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.UISystemProfilerApi.SampleType), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Layout", UnityEngine.UISystemProfilerApi.SampleType.Layout);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Render", UnityEngine.UISystemProfilerApi.SampleType.Render);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.UISystemProfilerApi.SampleType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineUISystemProfilerApiSampleType(L, (UnityEngine.UISystemProfilerApi.SampleType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Layout"))
                {
                    translator.PushUnityEngineUISystemProfilerApiSampleType(L, UnityEngine.UISystemProfilerApi.SampleType.Layout);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Render"))
                {
                    translator.PushUnityEngineUISystemProfilerApiSampleType(L, UnityEngine.UISystemProfilerApi.SampleType.Render);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UISystemProfilerApi.SampleType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UISystemProfilerApi.SampleType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineNetworkingQosTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Networking.QosType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Networking.QosType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Networking.QosType), L, null, 12, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Unreliable", UnityEngine.Networking.QosType.Unreliable);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnreliableFragmented", UnityEngine.Networking.QosType.UnreliableFragmented);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnreliableSequenced", UnityEngine.Networking.QosType.UnreliableSequenced);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Reliable", UnityEngine.Networking.QosType.Reliable);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReliableFragmented", UnityEngine.Networking.QosType.ReliableFragmented);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReliableSequenced", UnityEngine.Networking.QosType.ReliableSequenced);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StateUpdate", UnityEngine.Networking.QosType.StateUpdate);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReliableStateUpdate", UnityEngine.Networking.QosType.ReliableStateUpdate);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AllCostDelivery", UnityEngine.Networking.QosType.AllCostDelivery);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnreliableFragmentedSequenced", UnityEngine.Networking.QosType.UnreliableFragmentedSequenced);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReliableFragmentedSequenced", UnityEngine.Networking.QosType.ReliableFragmentedSequenced);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Networking.QosType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineNetworkingQosType(L, (UnityEngine.Networking.QosType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Unreliable"))
                {
                    translator.PushUnityEngineNetworkingQosType(L, UnityEngine.Networking.QosType.Unreliable);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UnreliableFragmented"))
                {
                    translator.PushUnityEngineNetworkingQosType(L, UnityEngine.Networking.QosType.UnreliableFragmented);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UnreliableSequenced"))
                {
                    translator.PushUnityEngineNetworkingQosType(L, UnityEngine.Networking.QosType.UnreliableSequenced);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Reliable"))
                {
                    translator.PushUnityEngineNetworkingQosType(L, UnityEngine.Networking.QosType.Reliable);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ReliableFragmented"))
                {
                    translator.PushUnityEngineNetworkingQosType(L, UnityEngine.Networking.QosType.ReliableFragmented);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ReliableSequenced"))
                {
                    translator.PushUnityEngineNetworkingQosType(L, UnityEngine.Networking.QosType.ReliableSequenced);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "StateUpdate"))
                {
                    translator.PushUnityEngineNetworkingQosType(L, UnityEngine.Networking.QosType.StateUpdate);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ReliableStateUpdate"))
                {
                    translator.PushUnityEngineNetworkingQosType(L, UnityEngine.Networking.QosType.ReliableStateUpdate);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AllCostDelivery"))
                {
                    translator.PushUnityEngineNetworkingQosType(L, UnityEngine.Networking.QosType.AllCostDelivery);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UnreliableFragmentedSequenced"))
                {
                    translator.PushUnityEngineNetworkingQosType(L, UnityEngine.Networking.QosType.UnreliableFragmentedSequenced);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ReliableFragmentedSequenced"))
                {
                    translator.PushUnityEngineNetworkingQosType(L, UnityEngine.Networking.QosType.ReliableFragmentedSequenced);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Networking.QosType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Networking.QosType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineNetworkingNetworkErrorWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Networking.NetworkError), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Networking.NetworkError), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Networking.NetworkError), L, null, 14, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Ok", UnityEngine.Networking.NetworkError.Ok);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WrongHost", UnityEngine.Networking.NetworkError.WrongHost);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WrongConnection", UnityEngine.Networking.NetworkError.WrongConnection);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WrongChannel", UnityEngine.Networking.NetworkError.WrongChannel);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NoResources", UnityEngine.Networking.NetworkError.NoResources);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BadMessage", UnityEngine.Networking.NetworkError.BadMessage);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Timeout", UnityEngine.Networking.NetworkError.Timeout);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MessageToLong", UnityEngine.Networking.NetworkError.MessageToLong);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WrongOperation", UnityEngine.Networking.NetworkError.WrongOperation);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VersionMismatch", UnityEngine.Networking.NetworkError.VersionMismatch);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CRCMismatch", UnityEngine.Networking.NetworkError.CRCMismatch);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DNSFailure", UnityEngine.Networking.NetworkError.DNSFailure);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UsageError", UnityEngine.Networking.NetworkError.UsageError);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Networking.NetworkError), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineNetworkingNetworkError(L, (UnityEngine.Networking.NetworkError)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Ok"))
                {
                    translator.PushUnityEngineNetworkingNetworkError(L, UnityEngine.Networking.NetworkError.Ok);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "WrongHost"))
                {
                    translator.PushUnityEngineNetworkingNetworkError(L, UnityEngine.Networking.NetworkError.WrongHost);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "WrongConnection"))
                {
                    translator.PushUnityEngineNetworkingNetworkError(L, UnityEngine.Networking.NetworkError.WrongConnection);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "WrongChannel"))
                {
                    translator.PushUnityEngineNetworkingNetworkError(L, UnityEngine.Networking.NetworkError.WrongChannel);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "NoResources"))
                {
                    translator.PushUnityEngineNetworkingNetworkError(L, UnityEngine.Networking.NetworkError.NoResources);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "BadMessage"))
                {
                    translator.PushUnityEngineNetworkingNetworkError(L, UnityEngine.Networking.NetworkError.BadMessage);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Timeout"))
                {
                    translator.PushUnityEngineNetworkingNetworkError(L, UnityEngine.Networking.NetworkError.Timeout);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MessageToLong"))
                {
                    translator.PushUnityEngineNetworkingNetworkError(L, UnityEngine.Networking.NetworkError.MessageToLong);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "WrongOperation"))
                {
                    translator.PushUnityEngineNetworkingNetworkError(L, UnityEngine.Networking.NetworkError.WrongOperation);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "VersionMismatch"))
                {
                    translator.PushUnityEngineNetworkingNetworkError(L, UnityEngine.Networking.NetworkError.VersionMismatch);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CRCMismatch"))
                {
                    translator.PushUnityEngineNetworkingNetworkError(L, UnityEngine.Networking.NetworkError.CRCMismatch);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DNSFailure"))
                {
                    translator.PushUnityEngineNetworkingNetworkError(L, UnityEngine.Networking.NetworkError.DNSFailure);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "UsageError"))
                {
                    translator.PushUnityEngineNetworkingNetworkError(L, UnityEngine.Networking.NetworkError.UsageError);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Networking.NetworkError!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Networking.NetworkError! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineNetworkingReactorModelWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Networking.ReactorModel), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Networking.ReactorModel), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Networking.ReactorModel), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SelectReactor", UnityEngine.Networking.ReactorModel.SelectReactor);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FixRateReactor", UnityEngine.Networking.ReactorModel.FixRateReactor);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Networking.ReactorModel), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineNetworkingReactorModel(L, (UnityEngine.Networking.ReactorModel)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "SelectReactor"))
                {
                    translator.PushUnityEngineNetworkingReactorModel(L, UnityEngine.Networking.ReactorModel.SelectReactor);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FixRateReactor"))
                {
                    translator.PushUnityEngineNetworkingReactorModel(L, UnityEngine.Networking.ReactorModel.FixRateReactor);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Networking.ReactorModel!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Networking.ReactorModel! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineNetworkingConnectionAcksTypeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Networking.ConnectionAcksType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Networking.ConnectionAcksType), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Networking.ConnectionAcksType), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Acks32", UnityEngine.Networking.ConnectionAcksType.Acks32);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Acks64", UnityEngine.Networking.ConnectionAcksType.Acks64);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Acks96", UnityEngine.Networking.ConnectionAcksType.Acks96);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Acks128", UnityEngine.Networking.ConnectionAcksType.Acks128);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Networking.ConnectionAcksType), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineNetworkingConnectionAcksType(L, (UnityEngine.Networking.ConnectionAcksType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Acks32"))
                {
                    translator.PushUnityEngineNetworkingConnectionAcksType(L, UnityEngine.Networking.ConnectionAcksType.Acks32);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Acks64"))
                {
                    translator.PushUnityEngineNetworkingConnectionAcksType(L, UnityEngine.Networking.ConnectionAcksType.Acks64);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Acks96"))
                {
                    translator.PushUnityEngineNetworkingConnectionAcksType(L, UnityEngine.Networking.ConnectionAcksType.Acks96);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Acks128"))
                {
                    translator.PushUnityEngineNetworkingConnectionAcksType(L, UnityEngine.Networking.ConnectionAcksType.Acks128);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Networking.ConnectionAcksType!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Networking.ConnectionAcksType! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineNetworkingUnityWebRequestResultWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Networking.UnityWebRequest.Result), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Networking.UnityWebRequest.Result), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Networking.UnityWebRequest.Result), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "InProgress", UnityEngine.Networking.UnityWebRequest.Result.InProgress);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Success", UnityEngine.Networking.UnityWebRequest.Result.Success);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ConnectionError", UnityEngine.Networking.UnityWebRequest.Result.ConnectionError);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ProtocolError", UnityEngine.Networking.UnityWebRequest.Result.ProtocolError);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DataProcessingError", UnityEngine.Networking.UnityWebRequest.Result.DataProcessingError);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Networking.UnityWebRequest.Result), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineNetworkingUnityWebRequestResult(L, (UnityEngine.Networking.UnityWebRequest.Result)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "InProgress"))
                {
                    translator.PushUnityEngineNetworkingUnityWebRequestResult(L, UnityEngine.Networking.UnityWebRequest.Result.InProgress);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Success"))
                {
                    translator.PushUnityEngineNetworkingUnityWebRequestResult(L, UnityEngine.Networking.UnityWebRequest.Result.Success);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ConnectionError"))
                {
                    translator.PushUnityEngineNetworkingUnityWebRequestResult(L, UnityEngine.Networking.UnityWebRequest.Result.ConnectionError);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ProtocolError"))
                {
                    translator.PushUnityEngineNetworkingUnityWebRequestResult(L, UnityEngine.Networking.UnityWebRequest.Result.ProtocolError);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "DataProcessingError"))
                {
                    translator.PushUnityEngineNetworkingUnityWebRequestResult(L, UnityEngine.Networking.UnityWebRequest.Result.DataProcessingError);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Networking.UnityWebRequest.Result!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Networking.UnityWebRequest.Result! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineVideoVideoRenderModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Video.VideoRenderMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Video.VideoRenderMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Video.VideoRenderMode), L, null, 6, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CameraFarPlane", UnityEngine.Video.VideoRenderMode.CameraFarPlane);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CameraNearPlane", UnityEngine.Video.VideoRenderMode.CameraNearPlane);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RenderTexture", UnityEngine.Video.VideoRenderMode.RenderTexture);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MaterialOverride", UnityEngine.Video.VideoRenderMode.MaterialOverride);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "APIOnly", UnityEngine.Video.VideoRenderMode.APIOnly);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Video.VideoRenderMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineVideoVideoRenderMode(L, (UnityEngine.Video.VideoRenderMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "CameraFarPlane"))
                {
                    translator.PushUnityEngineVideoVideoRenderMode(L, UnityEngine.Video.VideoRenderMode.CameraFarPlane);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "CameraNearPlane"))
                {
                    translator.PushUnityEngineVideoVideoRenderMode(L, UnityEngine.Video.VideoRenderMode.CameraNearPlane);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "RenderTexture"))
                {
                    translator.PushUnityEngineVideoVideoRenderMode(L, UnityEngine.Video.VideoRenderMode.RenderTexture);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "MaterialOverride"))
                {
                    translator.PushUnityEngineVideoVideoRenderMode(L, UnityEngine.Video.VideoRenderMode.MaterialOverride);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "APIOnly"))
                {
                    translator.PushUnityEngineVideoVideoRenderMode(L, UnityEngine.Video.VideoRenderMode.APIOnly);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Video.VideoRenderMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Video.VideoRenderMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineVideoVideo3DLayoutWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Video.Video3DLayout), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Video.Video3DLayout), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Video.Video3DLayout), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "No3D", UnityEngine.Video.Video3DLayout.No3D);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SideBySide3D", UnityEngine.Video.Video3DLayout.SideBySide3D);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OverUnder3D", UnityEngine.Video.Video3DLayout.OverUnder3D);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Video.Video3DLayout), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineVideoVideo3DLayout(L, (UnityEngine.Video.Video3DLayout)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "No3D"))
                {
                    translator.PushUnityEngineVideoVideo3DLayout(L, UnityEngine.Video.Video3DLayout.No3D);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "SideBySide3D"))
                {
                    translator.PushUnityEngineVideoVideo3DLayout(L, UnityEngine.Video.Video3DLayout.SideBySide3D);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "OverUnder3D"))
                {
                    translator.PushUnityEngineVideoVideo3DLayout(L, UnityEngine.Video.Video3DLayout.OverUnder3D);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Video.Video3DLayout!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Video.Video3DLayout! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineVideoVideoAspectRatioWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Video.VideoAspectRatio), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Video.VideoAspectRatio), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Video.VideoAspectRatio), L, null, 7, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NoScaling", UnityEngine.Video.VideoAspectRatio.NoScaling);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FitVertically", UnityEngine.Video.VideoAspectRatio.FitVertically);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FitHorizontally", UnityEngine.Video.VideoAspectRatio.FitHorizontally);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FitInside", UnityEngine.Video.VideoAspectRatio.FitInside);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FitOutside", UnityEngine.Video.VideoAspectRatio.FitOutside);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Stretch", UnityEngine.Video.VideoAspectRatio.Stretch);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Video.VideoAspectRatio), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineVideoVideoAspectRatio(L, (UnityEngine.Video.VideoAspectRatio)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "NoScaling"))
                {
                    translator.PushUnityEngineVideoVideoAspectRatio(L, UnityEngine.Video.VideoAspectRatio.NoScaling);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FitVertically"))
                {
                    translator.PushUnityEngineVideoVideoAspectRatio(L, UnityEngine.Video.VideoAspectRatio.FitVertically);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FitHorizontally"))
                {
                    translator.PushUnityEngineVideoVideoAspectRatio(L, UnityEngine.Video.VideoAspectRatio.FitHorizontally);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FitInside"))
                {
                    translator.PushUnityEngineVideoVideoAspectRatio(L, UnityEngine.Video.VideoAspectRatio.FitInside);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "FitOutside"))
                {
                    translator.PushUnityEngineVideoVideoAspectRatio(L, UnityEngine.Video.VideoAspectRatio.FitOutside);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Stretch"))
                {
                    translator.PushUnityEngineVideoVideoAspectRatio(L, UnityEngine.Video.VideoAspectRatio.Stretch);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Video.VideoAspectRatio!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Video.VideoAspectRatio! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineVideoVideoTimeSourceWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Video.VideoTimeSource), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Video.VideoTimeSource), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Video.VideoTimeSource), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AudioDSPTimeSource", UnityEngine.Video.VideoTimeSource.AudioDSPTimeSource);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GameTimeSource", UnityEngine.Video.VideoTimeSource.GameTimeSource);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Video.VideoTimeSource), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineVideoVideoTimeSource(L, (UnityEngine.Video.VideoTimeSource)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "AudioDSPTimeSource"))
                {
                    translator.PushUnityEngineVideoVideoTimeSource(L, UnityEngine.Video.VideoTimeSource.AudioDSPTimeSource);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "GameTimeSource"))
                {
                    translator.PushUnityEngineVideoVideoTimeSource(L, UnityEngine.Video.VideoTimeSource.GameTimeSource);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Video.VideoTimeSource!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Video.VideoTimeSource! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineVideoVideoTimeReferenceWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Video.VideoTimeReference), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Video.VideoTimeReference), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Video.VideoTimeReference), L, null, 4, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Freerun", UnityEngine.Video.VideoTimeReference.Freerun);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "InternalTime", UnityEngine.Video.VideoTimeReference.InternalTime);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExternalTime", UnityEngine.Video.VideoTimeReference.ExternalTime);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Video.VideoTimeReference), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineVideoVideoTimeReference(L, (UnityEngine.Video.VideoTimeReference)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "Freerun"))
                {
                    translator.PushUnityEngineVideoVideoTimeReference(L, UnityEngine.Video.VideoTimeReference.Freerun);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "InternalTime"))
                {
                    translator.PushUnityEngineVideoVideoTimeReference(L, UnityEngine.Video.VideoTimeReference.InternalTime);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "ExternalTime"))
                {
                    translator.PushUnityEngineVideoVideoTimeReference(L, UnityEngine.Video.VideoTimeReference.ExternalTime);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Video.VideoTimeReference!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Video.VideoTimeReference! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineVideoVideoSourceWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Video.VideoSource), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Video.VideoSource), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Video.VideoSource), L, null, 3, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VideoClip", UnityEngine.Video.VideoSource.VideoClip);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Url", UnityEngine.Video.VideoSource.Url);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Video.VideoSource), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineVideoVideoSource(L, (UnityEngine.Video.VideoSource)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "VideoClip"))
                {
                    translator.PushUnityEngineVideoVideoSource(L, UnityEngine.Video.VideoSource.VideoClip);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Url"))
                {
                    translator.PushUnityEngineVideoVideoSource(L, UnityEngine.Video.VideoSource.Url);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Video.VideoSource!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Video.VideoSource! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
    public class UnityEngineVideoVideoAudioOutputModeWrap
    {
		public static void __Register(RealStatePtr L)
        {
		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
		    Utils.BeginObjectRegister(typeof(UnityEngine.Video.VideoAudioOutputMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityEngine.Video.VideoAudioOutputMode), L, translator, null, null, null, null, null);
			
			Utils.BeginClassRegister(typeof(UnityEngine.Video.VideoAudioOutputMode), L, null, 5, 0, 0);

            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Video.VideoAudioOutputMode.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AudioSource", UnityEngine.Video.VideoAudioOutputMode.AudioSource);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Direct", UnityEngine.Video.VideoAudioOutputMode.Direct);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "APIOnly", UnityEngine.Video.VideoAudioOutputMode.APIOnly);
            

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(UnityEngine.Video.VideoAudioOutputMode), L, translator);
        }
		
		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
		{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushUnityEngineVideoVideoAudioOutputMode(L, (UnityEngine.Video.VideoAudioOutputMode)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {

			    if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushUnityEngineVideoVideoAudioOutputMode(L, UnityEngine.Video.VideoAudioOutputMode.None);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "AudioSource"))
                {
                    translator.PushUnityEngineVideoVideoAudioOutputMode(L, UnityEngine.Video.VideoAudioOutputMode.AudioSource);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "Direct"))
                {
                    translator.PushUnityEngineVideoVideoAudioOutputMode(L, UnityEngine.Video.VideoAudioOutputMode.Direct);
                }
				else if (LuaAPI.xlua_is_eq_str(L, 1, "APIOnly"))
                {
                    translator.PushUnityEngineVideoVideoAudioOutputMode(L, UnityEngine.Video.VideoAudioOutputMode.APIOnly);
                }
				else
                {
                    return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Video.VideoAudioOutputMode!");
                }

            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Video.VideoAudioOutputMode! Expect number or string, got + " + lua_type);
            }

            return 1;
		}
	}
    
}